Linear.Matrix:det33 from linear-1.19.1.3

Percentage Accurate: 72.9% → 81.6%

Time: 30.1s

Alternatives: 36

Speedup: 0.7×

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

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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
    code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
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) {
	return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 72.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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
    code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
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) {
	return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 81.6% accurate, 0.5× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1
         (+
          (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
          (* j (- (* c t) (* i y))))))
   (if (<= t_1 INFINITY) t_1 (* (* t b) (- (/ (* j c) b) (/ (* x a) b))))))

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(t * b), $MachinePrecision] * N[(N[(N[(j * c), $MachinePrecision] / b), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

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

   1. Initial program 90.8%

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

   if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y))))

   1. Initial program 0.0%

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

   3. Taylor expanded in b around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 2: 59.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(c \cdot t - i \cdot y\right)\\ t_2 := i \cdot \left(y \cdot j\right)\\ t_3 := i \cdot \left(b \cdot a\right)\\ t_4 := y \cdot z - a \cdot t\\ \mathbf{if}\;x \leq -7.2 \cdot 10^{+160}:\\ \;\;\;\;x \cdot t\_4\\ \mathbf{elif}\;x \leq -3.2 \cdot 10^{-96}:\\ \;\;\;\;y \cdot \left(x \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;x \leq -3.9 \cdot 10^{-151}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right) - t\_2\\ \mathbf{elif}\;x \leq 10^{-276}:\\ \;\;\;\;a \cdot \left(i \cdot b\right) + t\_1\\ \mathbf{elif}\;x \leq 2.22 \cdot 10^{-153}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right) + t\_1\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{-84}:\\ \;\;\;\;\left(0 - t\_2\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{elif}\;x \leq 6 \cdot 10^{+75}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + t\_3\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(t\_4 + \frac{t\_3}{x}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* c t) (* i y))))
        (t_2 (* i (* y j)))
        (t_3 (* i (* b a)))
        (t_4 (- (* y z) (* a t))))
   (if (<= x -7.2e+160)
     (* x t_4)
     (if (<= x -3.2e-96)
       (+ (* y (* x z)) (* a (- (* b i) (* x t))))
       (if (<= x -3.9e-151)
         (- (* c (- (* t j) (* z b))) t_2)
         (if (<= x 1e-276)
           (+ (* a (* i b)) t_1)
           (if (<= x 2.22e-153)
             (+ (* (* z c) (- b)) t_1)
             (if (<= x 1.6e-84)
               (- (- 0.0 t_2) (* b (* z c)))
               (if (<= x 6e+75)
                 (+ (* t (- (* j c) (* x a))) t_3)
                 (* x (+ t_4 (/ t_3 x))))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((c * t) - (i * y));
	double t_2 = i * (y * j);
	double t_3 = i * (b * a);
	double t_4 = (y * z) - (a * t);
	double tmp;
	if (x <= -7.2e+160) {
		tmp = x * t_4;
	} else if (x <= -3.2e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -3.9e-151) {
		tmp = (c * ((t * j) - (z * b))) - t_2;
	} else if (x <= 1e-276) {
		tmp = (a * (i * b)) + t_1;
	} else if (x <= 2.22e-153) {
		tmp = ((z * c) * -b) + t_1;
	} else if (x <= 1.6e-84) {
		tmp = (0.0 - t_2) - (b * (z * c));
	} else if (x <= 6e+75) {
		tmp = (t * ((j * c) - (x * a))) + t_3;
	} else {
		tmp = x * (t_4 + (t_3 / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = j * ((c * t) - (i * y))
    t_2 = i * (y * j)
    t_3 = i * (b * a)
    t_4 = (y * z) - (a * t)
    if (x <= (-7.2d+160)) then
        tmp = x * t_4
    else if (x <= (-3.2d-96)) then
        tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
    else if (x <= (-3.9d-151)) then
        tmp = (c * ((t * j) - (z * b))) - t_2
    else if (x <= 1d-276) then
        tmp = (a * (i * b)) + t_1
    else if (x <= 2.22d-153) then
        tmp = ((z * c) * -b) + t_1
    else if (x <= 1.6d-84) then
        tmp = (0.0d0 - t_2) - (b * (z * c))
    else if (x <= 6d+75) then
        tmp = (t * ((j * c) - (x * a))) + t_3
    else
        tmp = x * (t_4 + (t_3 / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((c * t) - (i * y));
	double t_2 = i * (y * j);
	double t_3 = i * (b * a);
	double t_4 = (y * z) - (a * t);
	double tmp;
	if (x <= -7.2e+160) {
		tmp = x * t_4;
	} else if (x <= -3.2e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -3.9e-151) {
		tmp = (c * ((t * j) - (z * b))) - t_2;
	} else if (x <= 1e-276) {
		tmp = (a * (i * b)) + t_1;
	} else if (x <= 2.22e-153) {
		tmp = ((z * c) * -b) + t_1;
	} else if (x <= 1.6e-84) {
		tmp = (0.0 - t_2) - (b * (z * c));
	} else if (x <= 6e+75) {
		tmp = (t * ((j * c) - (x * a))) + t_3;
	} else {
		tmp = x * (t_4 + (t_3 / x));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((c * t) - (i * y))
	t_2 = i * (y * j)
	t_3 = i * (b * a)
	t_4 = (y * z) - (a * t)
	tmp = 0
	if x <= -7.2e+160:
		tmp = x * t_4
	elif x <= -3.2e-96:
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
	elif x <= -3.9e-151:
		tmp = (c * ((t * j) - (z * b))) - t_2
	elif x <= 1e-276:
		tmp = (a * (i * b)) + t_1
	elif x <= 2.22e-153:
		tmp = ((z * c) * -b) + t_1
	elif x <= 1.6e-84:
		tmp = (0.0 - t_2) - (b * (z * c))
	elif x <= 6e+75:
		tmp = (t * ((j * c) - (x * a))) + t_3
	else:
		tmp = x * (t_4 + (t_3 / x))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(c * t) - Float64(i * y)))
	t_2 = Float64(i * Float64(y * j))
	t_3 = Float64(i * Float64(b * a))
	t_4 = Float64(Float64(y * z) - Float64(a * t))
	tmp = 0.0
	if (x <= -7.2e+160)
		tmp = Float64(x * t_4);
	elseif (x <= -3.2e-96)
		tmp = Float64(Float64(y * Float64(x * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t))));
	elseif (x <= -3.9e-151)
		tmp = Float64(Float64(c * Float64(Float64(t * j) - Float64(z * b))) - t_2);
	elseif (x <= 1e-276)
		tmp = Float64(Float64(a * Float64(i * b)) + t_1);
	elseif (x <= 2.22e-153)
		tmp = Float64(Float64(Float64(z * c) * Float64(-b)) + t_1);
	elseif (x <= 1.6e-84)
		tmp = Float64(Float64(0.0 - t_2) - Float64(b * Float64(z * c)));
	elseif (x <= 6e+75)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + t_3);
	else
		tmp = Float64(x * Float64(t_4 + Float64(t_3 / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((c * t) - (i * y));
	t_2 = i * (y * j);
	t_3 = i * (b * a);
	t_4 = (y * z) - (a * t);
	tmp = 0.0;
	if (x <= -7.2e+160)
		tmp = x * t_4;
	elseif (x <= -3.2e-96)
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	elseif (x <= -3.9e-151)
		tmp = (c * ((t * j) - (z * b))) - t_2;
	elseif (x <= 1e-276)
		tmp = (a * (i * b)) + t_1;
	elseif (x <= 2.22e-153)
		tmp = ((z * c) * -b) + t_1;
	elseif (x <= 1.6e-84)
		tmp = (0.0 - t_2) - (b * (z * c));
	elseif (x <= 6e+75)
		tmp = (t * ((j * c) - (x * a))) + t_3;
	else
		tmp = x * (t_4 + (t_3 / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.2e+160], N[(x * t$95$4), $MachinePrecision], If[LessEqual[x, -3.2e-96], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.9e-151], N[(N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[x, 1e-276], N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, 2.22e-153], N[(N[(N[(z * c), $MachinePrecision] * (-b)), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, 1.6e-84], N[(N[(0.0 - t$95$2), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6e+75], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision], N[(x * N[(t$95$4 + N[(t$95$3 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]

Derivation

1. Split input into 8 regimes

2. if x < -7.20000000000000042e160

   1. Initial program 62.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.20000000000000042e160 < x < -3.20000000000000012e-96

   1. Initial program 79.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -3.20000000000000012e-96 < x < -3.90000000000000007e-151

   1. Initial program 64.6%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -3.90000000000000007e-151 < x < 1e-276

   1. Initial program 72.4%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1e-276 < x < 2.2200000000000001e-153

   1. Initial program 66.6%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.2200000000000001e-153 < x < 1.6e-84

   1. Initial program 68.4%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.6e-84 < x < 6e75

   1. Initial program 84.7%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 6e75 < x

   1. Initial program 68.8%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 3: 60.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j - z \cdot b\right) - i \cdot \left(y \cdot j\right)\\ t_2 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -1.1 \cdot 10^{+162}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \leq -8 \cdot 10^{-103}:\\ \;\;\;\;y \cdot \left(x \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;x \leq -6.8 \cdot 10^{-149}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -1.22 \cdot 10^{-151}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{elif}\;x \leq 1.9 \cdot 10^{-182}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{elif}\;x \leq 1.65 \cdot 10^{-84}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 7.2 \cdot 10^{+116}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + i \cdot \left(b \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (- (* c (- (* t j) (* z b))) (* i (* y j))))
        (t_2 (* x (- (* y z) (* a t)))))
   (if (<= x -1.1e+162)
     t_2
     (if (<= x -8e-103)
       (+ (* y (* x z)) (* a (- (* b i) (* x t))))
       (if (<= x -6.8e-149)
         t_1
         (if (<= x -1.22e-151)
           (* a (- (* i b) (* x t)))
           (if (<= x 1.9e-182)
             (+ (* (* z c) (- b)) (* j (- (* c t) (* i y))))
             (if (<= x 1.65e-84)
               t_1
               (if (<= x 7.2e+116)
                 (+ (* t (- (* j c) (* x a))) (* i (* b a)))
                 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (c * ((t * j) - (z * b))) - (i * (y * j));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -1.1e+162) {
		tmp = t_2;
	} else if (x <= -8e-103) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -6.8e-149) {
		tmp = t_1;
	} else if (x <= -1.22e-151) {
		tmp = a * ((i * b) - (x * t));
	} else if (x <= 1.9e-182) {
		tmp = ((z * c) * -b) + (j * ((c * t) - (i * y)));
	} else if (x <= 1.65e-84) {
		tmp = t_1;
	} else if (x <= 7.2e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (c * ((t * j) - (z * b))) - (i * (y * j))
    t_2 = x * ((y * z) - (a * t))
    if (x <= (-1.1d+162)) then
        tmp = t_2
    else if (x <= (-8d-103)) then
        tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
    else if (x <= (-6.8d-149)) then
        tmp = t_1
    else if (x <= (-1.22d-151)) then
        tmp = a * ((i * b) - (x * t))
    else if (x <= 1.9d-182) then
        tmp = ((z * c) * -b) + (j * ((c * t) - (i * y)))
    else if (x <= 1.65d-84) then
        tmp = t_1
    else if (x <= 7.2d+116) then
        tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
    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 t_1 = (c * ((t * j) - (z * b))) - (i * (y * j));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -1.1e+162) {
		tmp = t_2;
	} else if (x <= -8e-103) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -6.8e-149) {
		tmp = t_1;
	} else if (x <= -1.22e-151) {
		tmp = a * ((i * b) - (x * t));
	} else if (x <= 1.9e-182) {
		tmp = ((z * c) * -b) + (j * ((c * t) - (i * y)));
	} else if (x <= 1.65e-84) {
		tmp = t_1;
	} else if (x <= 7.2e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (c * ((t * j) - (z * b))) - (i * (y * j))
	t_2 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -1.1e+162:
		tmp = t_2
	elif x <= -8e-103:
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
	elif x <= -6.8e-149:
		tmp = t_1
	elif x <= -1.22e-151:
		tmp = a * ((i * b) - (x * t))
	elif x <= 1.9e-182:
		tmp = ((z * c) * -b) + (j * ((c * t) - (i * y)))
	elif x <= 1.65e-84:
		tmp = t_1
	elif x <= 7.2e+116:
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(c * Float64(Float64(t * j) - Float64(z * b))) - Float64(i * Float64(y * j)))
	t_2 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -1.1e+162)
		tmp = t_2;
	elseif (x <= -8e-103)
		tmp = Float64(Float64(y * Float64(x * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t))));
	elseif (x <= -6.8e-149)
		tmp = t_1;
	elseif (x <= -1.22e-151)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	elseif (x <= 1.9e-182)
		tmp = Float64(Float64(Float64(z * c) * Float64(-b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	elseif (x <= 1.65e-84)
		tmp = t_1;
	elseif (x <= 7.2e+116)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(i * Float64(b * a)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (c * ((t * j) - (z * b))) - (i * (y * j));
	t_2 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -1.1e+162)
		tmp = t_2;
	elseif (x <= -8e-103)
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	elseif (x <= -6.8e-149)
		tmp = t_1;
	elseif (x <= -1.22e-151)
		tmp = a * ((i * b) - (x * t));
	elseif (x <= 1.9e-182)
		tmp = ((z * c) * -b) + (j * ((c * t) - (i * y)));
	elseif (x <= 1.65e-84)
		tmp = t_1;
	elseif (x <= 7.2e+116)
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.1e+162], t$95$2, If[LessEqual[x, -8e-103], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.8e-149], t$95$1, If[LessEqual[x, -1.22e-151], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.9e-182], N[(N[(N[(z * c), $MachinePrecision] * (-b)), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.65e-84], t$95$1, If[LessEqual[x, 7.2e+116], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if x < -1.1000000000000001e162 or 7.19999999999999941e116 < x

   1. Initial program 65.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.1000000000000001e162 < x < -7.99999999999999966e-103

   1. Initial program 79.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -7.99999999999999966e-103 < x < -6.7999999999999998e-149 or 1.9000000000000002e-182 < x < 1.64999999999999992e-84

   1. Initial program 70.4%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -6.7999999999999998e-149 < x < -1.21999999999999997e-151

   1. Initial program 3.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.21999999999999997e-151 < x < 1.9000000000000002e-182

   1. Initial program 71.0%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.64999999999999992e-84 < x < 7.19999999999999941e116

   1. Initial program 84.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 4: 56.5% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ t_2 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -6.2 \cdot 10^{+124}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \leq -3.2 \cdot 10^{+22}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -2.2 \cdot 10^{-29}:\\ \;\;\;\;y \cdot \left(x \cdot z - \frac{x \cdot \left(a \cdot t\right)}{y}\right)\\ \mathbf{elif}\;x \leq -5.1 \cdot 10^{-84}:\\ \;\;\;\;y \cdot \left(x \cdot z - j \cdot i\right)\\ \mathbf{elif}\;x \leq 3.2 \cdot 10^{-228}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{-84}:\\ \;\;\;\;\left(0 - i \cdot \left(y \cdot j\right)\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{+116}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + i \cdot \left(b \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (+ (* a (* i b)) (* j (- (* c t) (* i y)))))
        (t_2 (* x (- (* y z) (* a t)))))
   (if (<= x -6.2e+124)
     t_2
     (if (<= x -3.2e+22)
       t_1
       (if (<= x -2.2e-29)
         (* y (- (* x z) (/ (* x (* a t)) y)))
         (if (<= x -5.1e-84)
           (* y (- (* x z) (* j i)))
           (if (<= x 3.2e-228)
             t_1
             (if (<= x 1.6e-84)
               (- (- 0.0 (* i (* y j))) (* b (* z c)))
               (if (<= x 1.02e+116)
                 (+ (* t (- (* j c) (* x a))) (* i (* b a)))
                 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -6.2e+124) {
		tmp = t_2;
	} else if (x <= -3.2e+22) {
		tmp = t_1;
	} else if (x <= -2.2e-29) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (x <= -5.1e-84) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= 3.2e-228) {
		tmp = t_1;
	} else if (x <= 1.6e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 1.02e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
    t_2 = x * ((y * z) - (a * t))
    if (x <= (-6.2d+124)) then
        tmp = t_2
    else if (x <= (-3.2d+22)) then
        tmp = t_1
    else if (x <= (-2.2d-29)) then
        tmp = y * ((x * z) - ((x * (a * t)) / y))
    else if (x <= (-5.1d-84)) then
        tmp = y * ((x * z) - (j * i))
    else if (x <= 3.2d-228) then
        tmp = t_1
    else if (x <= 1.6d-84) then
        tmp = (0.0d0 - (i * (y * j))) - (b * (z * c))
    else if (x <= 1.02d+116) then
        tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
    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 t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -6.2e+124) {
		tmp = t_2;
	} else if (x <= -3.2e+22) {
		tmp = t_1;
	} else if (x <= -2.2e-29) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (x <= -5.1e-84) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= 3.2e-228) {
		tmp = t_1;
	} else if (x <= 1.6e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 1.02e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
	t_2 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -6.2e+124:
		tmp = t_2
	elif x <= -3.2e+22:
		tmp = t_1
	elif x <= -2.2e-29:
		tmp = y * ((x * z) - ((x * (a * t)) / y))
	elif x <= -5.1e-84:
		tmp = y * ((x * z) - (j * i))
	elif x <= 3.2e-228:
		tmp = t_1
	elif x <= 1.6e-84:
		tmp = (0.0 - (i * (y * j))) - (b * (z * c))
	elif x <= 1.02e+116:
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	t_2 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -6.2e+124)
		tmp = t_2;
	elseif (x <= -3.2e+22)
		tmp = t_1;
	elseif (x <= -2.2e-29)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(Float64(x * Float64(a * t)) / y)));
	elseif (x <= -5.1e-84)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(j * i)));
	elseif (x <= 3.2e-228)
		tmp = t_1;
	elseif (x <= 1.6e-84)
		tmp = Float64(Float64(0.0 - Float64(i * Float64(y * j))) - Float64(b * Float64(z * c)));
	elseif (x <= 1.02e+116)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(i * Float64(b * a)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	t_2 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -6.2e+124)
		tmp = t_2;
	elseif (x <= -3.2e+22)
		tmp = t_1;
	elseif (x <= -2.2e-29)
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	elseif (x <= -5.1e-84)
		tmp = y * ((x * z) - (j * i));
	elseif (x <= 3.2e-228)
		tmp = t_1;
	elseif (x <= 1.6e-84)
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	elseif (x <= 1.02e+116)
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -6.2e+124], t$95$2, If[LessEqual[x, -3.2e+22], t$95$1, If[LessEqual[x, -2.2e-29], N[(y * N[(N[(x * z), $MachinePrecision] - N[(N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -5.1e-84], N[(y * N[(N[(x * z), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.2e-228], t$95$1, If[LessEqual[x, 1.6e-84], N[(N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.02e+116], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if x < -6.2000000000000004e124 or 1.0199999999999999e116 < x

   1. Initial program 67.5%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.2000000000000004e124 < x < -3.2e22 or -5.0999999999999996e-84 < x < 3.20000000000000022e-228

   1. Initial program 73.0%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.2e22 < x < -2.1999999999999999e-29

   1. Initial program 87.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.1999999999999999e-29 < x < -5.0999999999999996e-84

   1. Initial program 63.7%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 3.20000000000000022e-228 < x < 1.6e-84

   1. Initial program 69.5%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.6e-84 < x < 1.0199999999999999e116

   1. Initial program 84.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 5: 56.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ t_2 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -3 \cdot 10^{+126}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \leq -1.32 \cdot 10^{+22}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -4.2 \cdot 10^{-33}:\\ \;\;\;\;y \cdot \left(x \cdot z - \frac{x \cdot \left(a \cdot t\right)}{y}\right)\\ \mathbf{elif}\;x \leq -6 \cdot 10^{-87}:\\ \;\;\;\;y \cdot \left(x \cdot z - j \cdot i\right)\\ \mathbf{elif}\;x \leq 1.04 \cdot 10^{-221}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 1.22 \cdot 10^{-80}:\\ \;\;\;\;\left(0 - i \cdot \left(y \cdot j\right)\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{elif}\;x \leq 1.22 \cdot 10^{+100}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (+ (* a (* i b)) (* j (- (* c t) (* i y)))))
        (t_2 (* x (- (* y z) (* a t)))))
   (if (<= x -3e+126)
     t_2
     (if (<= x -1.32e+22)
       t_1
       (if (<= x -4.2e-33)
         (* y (- (* x z) (/ (* x (* a t)) y)))
         (if (<= x -6e-87)
           (* y (- (* x z) (* j i)))
           (if (<= x 1.04e-221)
             t_1
             (if (<= x 1.22e-80)
               (- (- 0.0 (* i (* y j))) (* b (* z c)))
               (if (<= x 1.22e+100) t_1 t_2)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -3e+126) {
		tmp = t_2;
	} else if (x <= -1.32e+22) {
		tmp = t_1;
	} else if (x <= -4.2e-33) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (x <= -6e-87) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= 1.04e-221) {
		tmp = t_1;
	} else if (x <= 1.22e-80) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 1.22e+100) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
    t_2 = x * ((y * z) - (a * t))
    if (x <= (-3d+126)) then
        tmp = t_2
    else if (x <= (-1.32d+22)) then
        tmp = t_1
    else if (x <= (-4.2d-33)) then
        tmp = y * ((x * z) - ((x * (a * t)) / y))
    else if (x <= (-6d-87)) then
        tmp = y * ((x * z) - (j * i))
    else if (x <= 1.04d-221) then
        tmp = t_1
    else if (x <= 1.22d-80) then
        tmp = (0.0d0 - (i * (y * j))) - (b * (z * c))
    else if (x <= 1.22d+100) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -3e+126) {
		tmp = t_2;
	} else if (x <= -1.32e+22) {
		tmp = t_1;
	} else if (x <= -4.2e-33) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (x <= -6e-87) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= 1.04e-221) {
		tmp = t_1;
	} else if (x <= 1.22e-80) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 1.22e+100) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
	t_2 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -3e+126:
		tmp = t_2
	elif x <= -1.32e+22:
		tmp = t_1
	elif x <= -4.2e-33:
		tmp = y * ((x * z) - ((x * (a * t)) / y))
	elif x <= -6e-87:
		tmp = y * ((x * z) - (j * i))
	elif x <= 1.04e-221:
		tmp = t_1
	elif x <= 1.22e-80:
		tmp = (0.0 - (i * (y * j))) - (b * (z * c))
	elif x <= 1.22e+100:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	t_2 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -3e+126)
		tmp = t_2;
	elseif (x <= -1.32e+22)
		tmp = t_1;
	elseif (x <= -4.2e-33)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(Float64(x * Float64(a * t)) / y)));
	elseif (x <= -6e-87)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(j * i)));
	elseif (x <= 1.04e-221)
		tmp = t_1;
	elseif (x <= 1.22e-80)
		tmp = Float64(Float64(0.0 - Float64(i * Float64(y * j))) - Float64(b * Float64(z * c)));
	elseif (x <= 1.22e+100)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	t_2 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -3e+126)
		tmp = t_2;
	elseif (x <= -1.32e+22)
		tmp = t_1;
	elseif (x <= -4.2e-33)
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	elseif (x <= -6e-87)
		tmp = y * ((x * z) - (j * i));
	elseif (x <= 1.04e-221)
		tmp = t_1;
	elseif (x <= 1.22e-80)
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	elseif (x <= 1.22e+100)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3e+126], t$95$2, If[LessEqual[x, -1.32e+22], t$95$1, If[LessEqual[x, -4.2e-33], N[(y * N[(N[(x * z), $MachinePrecision] - N[(N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6e-87], N[(y * N[(N[(x * z), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.04e-221], t$95$1, If[LessEqual[x, 1.22e-80], N[(N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.22e+100], t$95$1, t$95$2]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -3.0000000000000002e126 or 1.21999999999999995e100 < x

   1. Initial program 67.8%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.0000000000000002e126 < x < -1.32e22 or -6.00000000000000033e-87 < x < 1.0399999999999999e-221 or 1.22e-80 < x < 1.21999999999999995e100

   1. Initial program 76.1%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.32e22 < x < -4.2e-33

   1. Initial program 87.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -4.2e-33 < x < -6.00000000000000033e-87

   1. Initial program 63.7%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.0399999999999999e-221 < x < 1.22e-80

   1. Initial program 71.3%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 6: 67.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := y \cdot z - a \cdot t\\ t_3 := x \cdot t\_2\\ t_4 := \left(t\_3 + a \cdot \left(i \cdot b\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;x \leq -3.55 \cdot 10^{+134}:\\ \;\;\;\;x \cdot \left(t\_2 + \frac{i \cdot \left(b \cdot a\right)}{x}\right)\\ \mathbf{elif}\;x \leq -6.3 \cdot 10^{-143}:\\ \;\;\;\;t\_4\\ \mathbf{elif}\;x \leq 2.3 \cdot 10^{-239}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + t\_1\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{-80}:\\ \;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + c \cdot \left(j \cdot t - z \cdot b\right)\\ \mathbf{elif}\;x \leq 5.8 \cdot 10^{+171}:\\ \;\;\;\;t\_4\\ \mathbf{else}:\\ \;\;\;\;t\_3 + t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* b (- (* a i) (* z c))))
        (t_2 (- (* y z) (* a t)))
        (t_3 (* x t_2))
        (t_4 (+ (+ t_3 (* a (* i b))) (* j (- (* c t) (* i y))))))
   (if (<= x -3.55e+134)
     (* x (+ t_2 (/ (* i (* b a)) x)))
     (if (<= x -6.3e-143)
       t_4
       (if (<= x 2.3e-239)
         (+ (* t (- (* j c) (* x a))) t_1)
         (if (<= x 1.55e-80)
           (+ (* y (- (* x z) (* i j))) (* c (- (* j t) (* z b))))
           (if (<= x 5.8e+171) t_4 (+ t_3 t_1))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = (y * z) - (a * t);
	double t_3 = x * t_2;
	double t_4 = (t_3 + (a * (i * b))) + (j * ((c * t) - (i * y)));
	double tmp;
	if (x <= -3.55e+134) {
		tmp = x * (t_2 + ((i * (b * a)) / x));
	} else if (x <= -6.3e-143) {
		tmp = t_4;
	} else if (x <= 2.3e-239) {
		tmp = (t * ((j * c) - (x * a))) + t_1;
	} else if (x <= 1.55e-80) {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	} else if (x <= 5.8e+171) {
		tmp = t_4;
	} else {
		tmp = t_3 + t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    t_2 = (y * z) - (a * t)
    t_3 = x * t_2
    t_4 = (t_3 + (a * (i * b))) + (j * ((c * t) - (i * y)))
    if (x <= (-3.55d+134)) then
        tmp = x * (t_2 + ((i * (b * a)) / x))
    else if (x <= (-6.3d-143)) then
        tmp = t_4
    else if (x <= 2.3d-239) then
        tmp = (t * ((j * c) - (x * a))) + t_1
    else if (x <= 1.55d-80) then
        tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
    else if (x <= 5.8d+171) then
        tmp = t_4
    else
        tmp = t_3 + t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = (y * z) - (a * t);
	double t_3 = x * t_2;
	double t_4 = (t_3 + (a * (i * b))) + (j * ((c * t) - (i * y)));
	double tmp;
	if (x <= -3.55e+134) {
		tmp = x * (t_2 + ((i * (b * a)) / x));
	} else if (x <= -6.3e-143) {
		tmp = t_4;
	} else if (x <= 2.3e-239) {
		tmp = (t * ((j * c) - (x * a))) + t_1;
	} else if (x <= 1.55e-80) {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	} else if (x <= 5.8e+171) {
		tmp = t_4;
	} else {
		tmp = t_3 + t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	t_2 = (y * z) - (a * t)
	t_3 = x * t_2
	t_4 = (t_3 + (a * (i * b))) + (j * ((c * t) - (i * y)))
	tmp = 0
	if x <= -3.55e+134:
		tmp = x * (t_2 + ((i * (b * a)) / x))
	elif x <= -6.3e-143:
		tmp = t_4
	elif x <= 2.3e-239:
		tmp = (t * ((j * c) - (x * a))) + t_1
	elif x <= 1.55e-80:
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
	elif x <= 5.8e+171:
		tmp = t_4
	else:
		tmp = t_3 + t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	t_2 = Float64(Float64(y * z) - Float64(a * t))
	t_3 = Float64(x * t_2)
	t_4 = Float64(Float64(t_3 + Float64(a * Float64(i * b))) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	tmp = 0.0
	if (x <= -3.55e+134)
		tmp = Float64(x * Float64(t_2 + Float64(Float64(i * Float64(b * a)) / x)));
	elseif (x <= -6.3e-143)
		tmp = t_4;
	elseif (x <= 2.3e-239)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + t_1);
	elseif (x <= 1.55e-80)
		tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(c * Float64(Float64(j * t) - Float64(z * b))));
	elseif (x <= 5.8e+171)
		tmp = t_4;
	else
		tmp = Float64(t_3 + t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = b * ((a * i) - (z * c));
	t_2 = (y * z) - (a * t);
	t_3 = x * t_2;
	t_4 = (t_3 + (a * (i * b))) + (j * ((c * t) - (i * y)));
	tmp = 0.0;
	if (x <= -3.55e+134)
		tmp = x * (t_2 + ((i * (b * a)) / x));
	elseif (x <= -6.3e-143)
		tmp = t_4;
	elseif (x <= 2.3e-239)
		tmp = (t * ((j * c) - (x * a))) + t_1;
	elseif (x <= 1.55e-80)
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	elseif (x <= 5.8e+171)
		tmp = t_4;
	else
		tmp = t_3 + t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x * t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[(N[(t$95$3 + N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.55e+134], N[(x * N[(t$95$2 + N[(N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.3e-143], t$95$4, If[LessEqual[x, 2.3e-239], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, 1.55e-80], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(j * t), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 5.8e+171], t$95$4, N[(t$95$3 + t$95$1), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -3.54999999999999995e134

   1. Initial program 64.9%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -3.54999999999999995e134 < x < -6.30000000000000037e-143 or 1.55000000000000008e-80 < x < 5.79999999999999969e171

   1. Initial program 78.7%

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

   3. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.30000000000000037e-143 < x < 2.2999999999999999e-239

   1. Initial program 69.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.2999999999999999e-239 < x < 1.55000000000000008e-80

   1. Initial program 70.9%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.79999999999999969e171 < x

   1. Initial program 68.7%

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

   3. Taylor expanded in j around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 7: 62.3% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(j \cdot c - x \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := y \cdot z - a \cdot t\\ \mathbf{if}\;x \leq -2.6 \cdot 10^{+161}:\\ \;\;\;\;x \cdot t\_2\\ \mathbf{elif}\;x \leq -1.42 \cdot 10^{-96}:\\ \;\;\;\;y \cdot \left(x \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;x \leq -1.25 \cdot 10^{-143}:\\ \;\;\;\;\left(0 - x \cdot \left(a \cdot t\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{elif}\;x \leq 6.2 \cdot 10^{-245}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{-84}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right) - i \cdot \left(y \cdot j\right)\\ \mathbf{elif}\;x \leq 6.6 \cdot 10^{+71}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(t\_2 + \frac{i \cdot \left(b \cdot a\right)}{x}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (+ (* t (- (* j c) (* x a))) (* b (- (* a i) (* z c)))))
        (t_2 (- (* y z) (* a t))))
   (if (<= x -2.6e+161)
     (* x t_2)
     (if (<= x -1.42e-96)
       (+ (* y (* x z)) (* a (- (* b i) (* x t))))
       (if (<= x -1.25e-143)
         (+ (- 0.0 (* x (* a t))) (* j (- (* c t) (* i y))))
         (if (<= x 6.2e-245)
           t_1
           (if (<= x 1.6e-84)
             (- (* c (- (* t j) (* z b))) (* i (* y j)))
             (if (<= x 6.6e+71) t_1 (* x (+ t_2 (/ (* i (* b a)) x)))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (t * ((j * c) - (x * a))) + (b * ((a * i) - (z * c)));
	double t_2 = (y * z) - (a * t);
	double tmp;
	if (x <= -2.6e+161) {
		tmp = x * t_2;
	} else if (x <= -1.42e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -1.25e-143) {
		tmp = (0.0 - (x * (a * t))) + (j * ((c * t) - (i * y)));
	} else if (x <= 6.2e-245) {
		tmp = t_1;
	} else if (x <= 1.6e-84) {
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	} else if (x <= 6.6e+71) {
		tmp = t_1;
	} else {
		tmp = x * (t_2 + ((i * (b * a)) / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (t * ((j * c) - (x * a))) + (b * ((a * i) - (z * c)))
    t_2 = (y * z) - (a * t)
    if (x <= (-2.6d+161)) then
        tmp = x * t_2
    else if (x <= (-1.42d-96)) then
        tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
    else if (x <= (-1.25d-143)) then
        tmp = (0.0d0 - (x * (a * t))) + (j * ((c * t) - (i * y)))
    else if (x <= 6.2d-245) then
        tmp = t_1
    else if (x <= 1.6d-84) then
        tmp = (c * ((t * j) - (z * b))) - (i * (y * j))
    else if (x <= 6.6d+71) then
        tmp = t_1
    else
        tmp = x * (t_2 + ((i * (b * a)) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (t * ((j * c) - (x * a))) + (b * ((a * i) - (z * c)));
	double t_2 = (y * z) - (a * t);
	double tmp;
	if (x <= -2.6e+161) {
		tmp = x * t_2;
	} else if (x <= -1.42e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= -1.25e-143) {
		tmp = (0.0 - (x * (a * t))) + (j * ((c * t) - (i * y)));
	} else if (x <= 6.2e-245) {
		tmp = t_1;
	} else if (x <= 1.6e-84) {
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	} else if (x <= 6.6e+71) {
		tmp = t_1;
	} else {
		tmp = x * (t_2 + ((i * (b * a)) / x));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (t * ((j * c) - (x * a))) + (b * ((a * i) - (z * c)))
	t_2 = (y * z) - (a * t)
	tmp = 0
	if x <= -2.6e+161:
		tmp = x * t_2
	elif x <= -1.42e-96:
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
	elif x <= -1.25e-143:
		tmp = (0.0 - (x * (a * t))) + (j * ((c * t) - (i * y)))
	elif x <= 6.2e-245:
		tmp = t_1
	elif x <= 1.6e-84:
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j))
	elif x <= 6.6e+71:
		tmp = t_1
	else:
		tmp = x * (t_2 + ((i * (b * a)) / x))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c))))
	t_2 = Float64(Float64(y * z) - Float64(a * t))
	tmp = 0.0
	if (x <= -2.6e+161)
		tmp = Float64(x * t_2);
	elseif (x <= -1.42e-96)
		tmp = Float64(Float64(y * Float64(x * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t))));
	elseif (x <= -1.25e-143)
		tmp = Float64(Float64(0.0 - Float64(x * Float64(a * t))) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	elseif (x <= 6.2e-245)
		tmp = t_1;
	elseif (x <= 1.6e-84)
		tmp = Float64(Float64(c * Float64(Float64(t * j) - Float64(z * b))) - Float64(i * Float64(y * j)));
	elseif (x <= 6.6e+71)
		tmp = t_1;
	else
		tmp = Float64(x * Float64(t_2 + Float64(Float64(i * Float64(b * a)) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (t * ((j * c) - (x * a))) + (b * ((a * i) - (z * c)));
	t_2 = (y * z) - (a * t);
	tmp = 0.0;
	if (x <= -2.6e+161)
		tmp = x * t_2;
	elseif (x <= -1.42e-96)
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	elseif (x <= -1.25e-143)
		tmp = (0.0 - (x * (a * t))) + (j * ((c * t) - (i * y)));
	elseif (x <= 6.2e-245)
		tmp = t_1;
	elseif (x <= 1.6e-84)
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	elseif (x <= 6.6e+71)
		tmp = t_1;
	else
		tmp = x * (t_2 + ((i * (b * a)) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.6e+161], N[(x * t$95$2), $MachinePrecision], If[LessEqual[x, -1.42e-96], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.25e-143], N[(N[(0.0 - N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.2e-245], t$95$1, If[LessEqual[x, 1.6e-84], N[(N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.6e+71], t$95$1, N[(x * N[(t$95$2 + N[(N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if x < -2.5999999999999998e161

   1. Initial program 62.2%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.5999999999999998e161 < x < -1.42000000000000003e-96

   1. Initial program 79.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1.42000000000000003e-96 < x < -1.2500000000000001e-143

   1. Initial program 74.8%

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

   3. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.2500000000000001e-143 < x < 6.20000000000000006e-245 or 1.6e-84 < x < 6.5999999999999996e71

   1. Initial program 75.6%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 6.20000000000000006e-245 < x < 1.6e-84

   1. Initial program 69.3%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 6.5999999999999996e71 < x

   1. Initial program 67.4%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 8: 51.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\ t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_3 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -4.9 \cdot 10^{+50}:\\ \;\;\;\;t\_3\\ \mathbf{elif}\;x \leq -3 \cdot 10^{-109}:\\ \;\;\;\;y \cdot \left(x \cdot z - j \cdot i\right)\\ \mathbf{elif}\;x \leq -1.22 \cdot 10^{-147}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -2.26 \cdot 10^{-302}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{-247}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 1.8 \cdot 10^{-84}:\\ \;\;\;\;\left(0 - i \cdot \left(y \cdot j\right)\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{elif}\;x \leq 4.1 \cdot 10^{+81}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* c (- (* t j) (* z b))))
        (t_2 (* b (- (* a i) (* z c))))
        (t_3 (* x (- (* y z) (* a t)))))
   (if (<= x -4.9e+50)
     t_3
     (if (<= x -3e-109)
       (* y (- (* x z) (* j i)))
       (if (<= x -1.22e-147)
         t_1
         (if (<= x -2.26e-302)
           t_2
           (if (<= x 1.6e-247)
             t_1
             (if (<= x 1.8e-84)
               (- (- 0.0 (* i (* y j))) (* b (* z c)))
               (if (<= x 4.1e+81) t_2 t_3)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double t_2 = b * ((a * i) - (z * c));
	double t_3 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -4.9e+50) {
		tmp = t_3;
	} else if (x <= -3e-109) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= -1.22e-147) {
		tmp = t_1;
	} else if (x <= -2.26e-302) {
		tmp = t_2;
	} else if (x <= 1.6e-247) {
		tmp = t_1;
	} else if (x <= 1.8e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 4.1e+81) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = c * ((t * j) - (z * b))
    t_2 = b * ((a * i) - (z * c))
    t_3 = x * ((y * z) - (a * t))
    if (x <= (-4.9d+50)) then
        tmp = t_3
    else if (x <= (-3d-109)) then
        tmp = y * ((x * z) - (j * i))
    else if (x <= (-1.22d-147)) then
        tmp = t_1
    else if (x <= (-2.26d-302)) then
        tmp = t_2
    else if (x <= 1.6d-247) then
        tmp = t_1
    else if (x <= 1.8d-84) then
        tmp = (0.0d0 - (i * (y * j))) - (b * (z * c))
    else if (x <= 4.1d+81) then
        tmp = t_2
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double t_2 = b * ((a * i) - (z * c));
	double t_3 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -4.9e+50) {
		tmp = t_3;
	} else if (x <= -3e-109) {
		tmp = y * ((x * z) - (j * i));
	} else if (x <= -1.22e-147) {
		tmp = t_1;
	} else if (x <= -2.26e-302) {
		tmp = t_2;
	} else if (x <= 1.6e-247) {
		tmp = t_1;
	} else if (x <= 1.8e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 4.1e+81) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((t * j) - (z * b))
	t_2 = b * ((a * i) - (z * c))
	t_3 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -4.9e+50:
		tmp = t_3
	elif x <= -3e-109:
		tmp = y * ((x * z) - (j * i))
	elif x <= -1.22e-147:
		tmp = t_1
	elif x <= -2.26e-302:
		tmp = t_2
	elif x <= 1.6e-247:
		tmp = t_1
	elif x <= 1.8e-84:
		tmp = (0.0 - (i * (y * j))) - (b * (z * c))
	elif x <= 4.1e+81:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b)))
	t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	t_3 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -4.9e+50)
		tmp = t_3;
	elseif (x <= -3e-109)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(j * i)));
	elseif (x <= -1.22e-147)
		tmp = t_1;
	elseif (x <= -2.26e-302)
		tmp = t_2;
	elseif (x <= 1.6e-247)
		tmp = t_1;
	elseif (x <= 1.8e-84)
		tmp = Float64(Float64(0.0 - Float64(i * Float64(y * j))) - Float64(b * Float64(z * c)));
	elseif (x <= 4.1e+81)
		tmp = t_2;
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = c * ((t * j) - (z * b));
	t_2 = b * ((a * i) - (z * c));
	t_3 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -4.9e+50)
		tmp = t_3;
	elseif (x <= -3e-109)
		tmp = y * ((x * z) - (j * i));
	elseif (x <= -1.22e-147)
		tmp = t_1;
	elseif (x <= -2.26e-302)
		tmp = t_2;
	elseif (x <= 1.6e-247)
		tmp = t_1;
	elseif (x <= 1.8e-84)
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	elseif (x <= 4.1e+81)
		tmp = t_2;
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.9e+50], t$95$3, If[LessEqual[x, -3e-109], N[(y * N[(N[(x * z), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.22e-147], t$95$1, If[LessEqual[x, -2.26e-302], t$95$2, If[LessEqual[x, 1.6e-247], t$95$1, If[LessEqual[x, 1.8e-84], N[(N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.1e+81], t$95$2, t$95$3]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -4.9000000000000002e50 or 4.10000000000000012e81 < x

   1. Initial program 70.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4.9000000000000002e50 < x < -3.00000000000000021e-109

   1. Initial program 75.5%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.00000000000000021e-109 < x < -1.21999999999999995e-147 or -2.2600000000000001e-302 < x < 1.59999999999999997e-247

   1. Initial program 66.9%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.21999999999999995e-147 < x < -2.2600000000000001e-302 or 1.80000000000000002e-84 < x < 4.10000000000000012e81

   1. Initial program 78.1%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.59999999999999997e-247 < x < 1.80000000000000002e-84

   1. Initial program 68.5%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 9: 28.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -9.5 \cdot 10^{+138}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right)\\ \mathbf{elif}\;c \leq -21000:\\ \;\;\;\;-x \cdot \left(a \cdot t\right)\\ \mathbf{elif}\;c \leq -1.4 \cdot 10^{-111}:\\ \;\;\;\;i \cdot \left(b \cdot a\right)\\ \mathbf{elif}\;c \leq -1.5 \cdot 10^{-237}:\\ \;\;\;\;\left(x \cdot t\right) \cdot \left(-a\right)\\ \mathbf{elif}\;c \leq 2.3 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 3.5 \cdot 10^{-85}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;c \leq 2 \cdot 10^{+125}:\\ \;\;\;\;0 - i \cdot \left(y \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -9.5e+138)
   (* (* z c) (- b))
   (if (<= c -21000.0)
     (- (* x (* a t)))
     (if (<= c -1.4e-111)
       (* i (* b a))
       (if (<= c -1.5e-237)
         (* (* x t) (- a))
         (if (<= c 2.3e-296)
           (* (* a i) b)
           (if (<= c 3.5e-85)
             (* y (* x z))
             (if (<= c 2e+125) (- 0.0 (* i (* y j))) (* j (* c t))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -9.5e+138) {
		tmp = (z * c) * -b;
	} else if (c <= -21000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -1.4e-111) {
		tmp = i * (b * a);
	} else if (c <= -1.5e-237) {
		tmp = (x * t) * -a;
	} else if (c <= 2.3e-296) {
		tmp = (a * i) * b;
	} else if (c <= 3.5e-85) {
		tmp = y * (x * z);
	} else if (c <= 2e+125) {
		tmp = 0.0 - (i * (y * j));
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-9.5d+138)) then
        tmp = (z * c) * -b
    else if (c <= (-21000.0d0)) then
        tmp = -(x * (a * t))
    else if (c <= (-1.4d-111)) then
        tmp = i * (b * a)
    else if (c <= (-1.5d-237)) then
        tmp = (x * t) * -a
    else if (c <= 2.3d-296) then
        tmp = (a * i) * b
    else if (c <= 3.5d-85) then
        tmp = y * (x * z)
    else if (c <= 2d+125) then
        tmp = 0.0d0 - (i * (y * j))
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -9.5e+138) {
		tmp = (z * c) * -b;
	} else if (c <= -21000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -1.4e-111) {
		tmp = i * (b * a);
	} else if (c <= -1.5e-237) {
		tmp = (x * t) * -a;
	} else if (c <= 2.3e-296) {
		tmp = (a * i) * b;
	} else if (c <= 3.5e-85) {
		tmp = y * (x * z);
	} else if (c <= 2e+125) {
		tmp = 0.0 - (i * (y * j));
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -9.5e+138:
		tmp = (z * c) * -b
	elif c <= -21000.0:
		tmp = -(x * (a * t))
	elif c <= -1.4e-111:
		tmp = i * (b * a)
	elif c <= -1.5e-237:
		tmp = (x * t) * -a
	elif c <= 2.3e-296:
		tmp = (a * i) * b
	elif c <= 3.5e-85:
		tmp = y * (x * z)
	elif c <= 2e+125:
		tmp = 0.0 - (i * (y * j))
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -9.5e+138)
		tmp = Float64(Float64(z * c) * Float64(-b));
	elseif (c <= -21000.0)
		tmp = Float64(-Float64(x * Float64(a * t)));
	elseif (c <= -1.4e-111)
		tmp = Float64(i * Float64(b * a));
	elseif (c <= -1.5e-237)
		tmp = Float64(Float64(x * t) * Float64(-a));
	elseif (c <= 2.3e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 3.5e-85)
		tmp = Float64(y * Float64(x * z));
	elseif (c <= 2e+125)
		tmp = Float64(0.0 - Float64(i * Float64(y * j)));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -9.5e+138)
		tmp = (z * c) * -b;
	elseif (c <= -21000.0)
		tmp = -(x * (a * t));
	elseif (c <= -1.4e-111)
		tmp = i * (b * a);
	elseif (c <= -1.5e-237)
		tmp = (x * t) * -a;
	elseif (c <= 2.3e-296)
		tmp = (a * i) * b;
	elseif (c <= 3.5e-85)
		tmp = y * (x * z);
	elseif (c <= 2e+125)
		tmp = 0.0 - (i * (y * j));
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -9.5e+138], N[(N[(z * c), $MachinePrecision] * (-b)), $MachinePrecision], If[LessEqual[c, -21000.0], (-N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, -1.4e-111], N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.5e-237], N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision], If[LessEqual[c, 2.3e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 3.5e-85], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2e+125], N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 8 regimes

2. if c < -9.49999999999999998e138

   1. Initial program 56.4%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -9.49999999999999998e138 < c < -21000

   1. Initial program 65.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -21000 < c < -1.39999999999999998e-111

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.39999999999999998e-111 < c < -1.50000000000000012e-237

   1. Initial program 86.5%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.50000000000000012e-237 < c < 2.30000000000000004e-296

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.30000000000000004e-296 < c < 3.49999999999999978e-85

   1. Initial program 77.8%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.49999999999999978e-85 < c < 1.9999999999999998e125

   1. Initial program 73.0%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.9999999999999998e125 < c

   1. Initial program 66.0%

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

   3. Taylor expanded in y around 0 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 8 regimes into one program.
4. Add Preprocessing

Alternative 10: 28.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -7.4 \cdot 10^{+136}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right)\\ \mathbf{elif}\;c \leq -13000:\\ \;\;\;\;-x \cdot \left(a \cdot t\right)\\ \mathbf{elif}\;c \leq -2.2 \cdot 10^{-111}:\\ \;\;\;\;i \cdot \left(b \cdot a\right)\\ \mathbf{elif}\;c \leq -2.9 \cdot 10^{-238}:\\ \;\;\;\;\left(x \cdot t\right) \cdot \left(-a\right)\\ \mathbf{elif}\;c \leq 3.5 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 1.6 \cdot 10^{-85}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;c \leq 2.8 \cdot 10^{+125}:\\ \;\;\;\;y \cdot \left(j \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -7.4e+136)
   (* (* z c) (- b))
   (if (<= c -13000.0)
     (- (* x (* a t)))
     (if (<= c -2.2e-111)
       (* i (* b a))
       (if (<= c -2.9e-238)
         (* (* x t) (- a))
         (if (<= c 3.5e-296)
           (* (* a i) b)
           (if (<= c 1.6e-85)
             (* y (* x z))
             (if (<= c 2.8e+125) (* y (* j (- i))) (* j (* c t))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -7.4e+136) {
		tmp = (z * c) * -b;
	} else if (c <= -13000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -2.2e-111) {
		tmp = i * (b * a);
	} else if (c <= -2.9e-238) {
		tmp = (x * t) * -a;
	} else if (c <= 3.5e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.6e-85) {
		tmp = y * (x * z);
	} else if (c <= 2.8e+125) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-7.4d+136)) then
        tmp = (z * c) * -b
    else if (c <= (-13000.0d0)) then
        tmp = -(x * (a * t))
    else if (c <= (-2.2d-111)) then
        tmp = i * (b * a)
    else if (c <= (-2.9d-238)) then
        tmp = (x * t) * -a
    else if (c <= 3.5d-296) then
        tmp = (a * i) * b
    else if (c <= 1.6d-85) then
        tmp = y * (x * z)
    else if (c <= 2.8d+125) then
        tmp = y * (j * -i)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -7.4e+136) {
		tmp = (z * c) * -b;
	} else if (c <= -13000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -2.2e-111) {
		tmp = i * (b * a);
	} else if (c <= -2.9e-238) {
		tmp = (x * t) * -a;
	} else if (c <= 3.5e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.6e-85) {
		tmp = y * (x * z);
	} else if (c <= 2.8e+125) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -7.4e+136:
		tmp = (z * c) * -b
	elif c <= -13000.0:
		tmp = -(x * (a * t))
	elif c <= -2.2e-111:
		tmp = i * (b * a)
	elif c <= -2.9e-238:
		tmp = (x * t) * -a
	elif c <= 3.5e-296:
		tmp = (a * i) * b
	elif c <= 1.6e-85:
		tmp = y * (x * z)
	elif c <= 2.8e+125:
		tmp = y * (j * -i)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -7.4e+136)
		tmp = Float64(Float64(z * c) * Float64(-b));
	elseif (c <= -13000.0)
		tmp = Float64(-Float64(x * Float64(a * t)));
	elseif (c <= -2.2e-111)
		tmp = Float64(i * Float64(b * a));
	elseif (c <= -2.9e-238)
		tmp = Float64(Float64(x * t) * Float64(-a));
	elseif (c <= 3.5e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 1.6e-85)
		tmp = Float64(y * Float64(x * z));
	elseif (c <= 2.8e+125)
		tmp = Float64(y * Float64(j * Float64(-i)));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -7.4e+136)
		tmp = (z * c) * -b;
	elseif (c <= -13000.0)
		tmp = -(x * (a * t));
	elseif (c <= -2.2e-111)
		tmp = i * (b * a);
	elseif (c <= -2.9e-238)
		tmp = (x * t) * -a;
	elseif (c <= 3.5e-296)
		tmp = (a * i) * b;
	elseif (c <= 1.6e-85)
		tmp = y * (x * z);
	elseif (c <= 2.8e+125)
		tmp = y * (j * -i);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -7.4e+136], N[(N[(z * c), $MachinePrecision] * (-b)), $MachinePrecision], If[LessEqual[c, -13000.0], (-N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, -2.2e-111], N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -2.9e-238], N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision], If[LessEqual[c, 3.5e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 1.6e-85], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.8e+125], N[(y * N[(j * (-i)), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 8 regimes

2. if c < -7.4000000000000002e136

   1. Initial program 56.4%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -7.4000000000000002e136 < c < -13000

   1. Initial program 65.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -13000 < c < -2.2e-111

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.2e-111 < c < -2.8999999999999998e-238

   1. Initial program 86.5%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.8999999999999998e-238 < c < 3.4999999999999999e-296

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 3.4999999999999999e-296 < c < 1.60000000000000014e-85

   1. Initial program 77.8%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.60000000000000014e-85 < c < 2.8000000000000001e125

   1. Initial program 73.0%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.8000000000000001e125 < c

   1. Initial program 66.0%

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

   3. Taylor expanded in y around 0 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 8 regimes into one program.
4. Add Preprocessing

Alternative 11: 28.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -5.4 \cdot 10^{+135}:\\ \;\;\;\;\left(c \cdot j\right) \cdot t\\ \mathbf{elif}\;c \leq -17000:\\ \;\;\;\;-x \cdot \left(a \cdot t\right)\\ \mathbf{elif}\;c \leq -7 \cdot 10^{-111}:\\ \;\;\;\;i \cdot \left(b \cdot a\right)\\ \mathbf{elif}\;c \leq -1.35 \cdot 10^{-237}:\\ \;\;\;\;\left(x \cdot t\right) \cdot \left(-a\right)\\ \mathbf{elif}\;c \leq 3.3 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 2.2 \cdot 10^{-85}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;c \leq 2.6 \cdot 10^{+125}:\\ \;\;\;\;y \cdot \left(j \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -5.4e+135)
   (* (* c j) t)
   (if (<= c -17000.0)
     (- (* x (* a t)))
     (if (<= c -7e-111)
       (* i (* b a))
       (if (<= c -1.35e-237)
         (* (* x t) (- a))
         (if (<= c 3.3e-296)
           (* (* a i) b)
           (if (<= c 2.2e-85)
             (* y (* x z))
             (if (<= c 2.6e+125) (* y (* j (- i))) (* j (* c t))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -5.4e+135) {
		tmp = (c * j) * t;
	} else if (c <= -17000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -7e-111) {
		tmp = i * (b * a);
	} else if (c <= -1.35e-237) {
		tmp = (x * t) * -a;
	} else if (c <= 3.3e-296) {
		tmp = (a * i) * b;
	} else if (c <= 2.2e-85) {
		tmp = y * (x * z);
	} else if (c <= 2.6e+125) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-5.4d+135)) then
        tmp = (c * j) * t
    else if (c <= (-17000.0d0)) then
        tmp = -(x * (a * t))
    else if (c <= (-7d-111)) then
        tmp = i * (b * a)
    else if (c <= (-1.35d-237)) then
        tmp = (x * t) * -a
    else if (c <= 3.3d-296) then
        tmp = (a * i) * b
    else if (c <= 2.2d-85) then
        tmp = y * (x * z)
    else if (c <= 2.6d+125) then
        tmp = y * (j * -i)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -5.4e+135) {
		tmp = (c * j) * t;
	} else if (c <= -17000.0) {
		tmp = -(x * (a * t));
	} else if (c <= -7e-111) {
		tmp = i * (b * a);
	} else if (c <= -1.35e-237) {
		tmp = (x * t) * -a;
	} else if (c <= 3.3e-296) {
		tmp = (a * i) * b;
	} else if (c <= 2.2e-85) {
		tmp = y * (x * z);
	} else if (c <= 2.6e+125) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -5.4e+135:
		tmp = (c * j) * t
	elif c <= -17000.0:
		tmp = -(x * (a * t))
	elif c <= -7e-111:
		tmp = i * (b * a)
	elif c <= -1.35e-237:
		tmp = (x * t) * -a
	elif c <= 3.3e-296:
		tmp = (a * i) * b
	elif c <= 2.2e-85:
		tmp = y * (x * z)
	elif c <= 2.6e+125:
		tmp = y * (j * -i)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -5.4e+135)
		tmp = Float64(Float64(c * j) * t);
	elseif (c <= -17000.0)
		tmp = Float64(-Float64(x * Float64(a * t)));
	elseif (c <= -7e-111)
		tmp = Float64(i * Float64(b * a));
	elseif (c <= -1.35e-237)
		tmp = Float64(Float64(x * t) * Float64(-a));
	elseif (c <= 3.3e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 2.2e-85)
		tmp = Float64(y * Float64(x * z));
	elseif (c <= 2.6e+125)
		tmp = Float64(y * Float64(j * Float64(-i)));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -5.4e+135)
		tmp = (c * j) * t;
	elseif (c <= -17000.0)
		tmp = -(x * (a * t));
	elseif (c <= -7e-111)
		tmp = i * (b * a);
	elseif (c <= -1.35e-237)
		tmp = (x * t) * -a;
	elseif (c <= 3.3e-296)
		tmp = (a * i) * b;
	elseif (c <= 2.2e-85)
		tmp = y * (x * z);
	elseif (c <= 2.6e+125)
		tmp = y * (j * -i);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -5.4e+135], N[(N[(c * j), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[c, -17000.0], (-N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, -7e-111], N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.35e-237], N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision], If[LessEqual[c, 3.3e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 2.2e-85], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.6e+125], N[(y * N[(j * (-i)), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 8 regimes

2. if c < -5.3999999999999997e135

   1. Initial program 55.1%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -5.3999999999999997e135 < c < -17000

   1. Initial program 67.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -17000 < c < -7.0000000000000001e-111

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -7.0000000000000001e-111 < c < -1.34999999999999992e-237

   1. Initial program 86.5%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -1.34999999999999992e-237 < c < 3.3e-296

   1. Initial program 81.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 3.3e-296 < c < 2.2e-85

   1. Initial program 77.8%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.2e-85 < c < 2.60000000000000003e125

   1. Initial program 73.0%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.60000000000000003e125 < c

   1. Initial program 66.0%

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

   3. Taylor expanded in y around 0 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 8 regimes into one program.
4. Add Preprocessing

Alternative 12: 59.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -6.5 \cdot 10^{+161}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -5.1 \cdot 10^{-84}:\\ \;\;\;\;y \cdot \left(x \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;x \leq 4.8 \cdot 10^{-226}:\\ \;\;\;\;a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{elif}\;x \leq 1.85 \cdot 10^{-84}:\\ \;\;\;\;\left(0 - i \cdot \left(y \cdot j\right)\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{elif}\;x \leq 3.75 \cdot 10^{+115}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + i \cdot \left(b \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* x (- (* y z) (* a t)))))
   (if (<= x -6.5e+161)
     t_1
     (if (<= x -5.1e-84)
       (+ (* y (* x z)) (* a (- (* b i) (* x t))))
       (if (<= x 4.8e-226)
         (+ (* a (* i b)) (* j (- (* c t) (* i y))))
         (if (<= x 1.85e-84)
           (- (- 0.0 (* i (* y j))) (* b (* z c)))
           (if (<= x 3.75e+115)
             (+ (* t (- (* j c) (* x a))) (* i (* b a)))
             t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -6.5e+161) {
		tmp = t_1;
	} else if (x <= -5.1e-84) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= 4.8e-226) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (x <= 1.85e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 3.75e+115) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = x * ((y * z) - (a * t))
    if (x <= (-6.5d+161)) then
        tmp = t_1
    else if (x <= (-5.1d-84)) then
        tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
    else if (x <= 4.8d-226) then
        tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
    else if (x <= 1.85d-84) then
        tmp = (0.0d0 - (i * (y * j))) - (b * (z * c))
    else if (x <= 3.75d+115) then
        tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -6.5e+161) {
		tmp = t_1;
	} else if (x <= -5.1e-84) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= 4.8e-226) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (x <= 1.85e-84) {
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	} else if (x <= 3.75e+115) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -6.5e+161:
		tmp = t_1
	elif x <= -5.1e-84:
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
	elif x <= 4.8e-226:
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
	elif x <= 1.85e-84:
		tmp = (0.0 - (i * (y * j))) - (b * (z * c))
	elif x <= 3.75e+115:
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -6.5e+161)
		tmp = t_1;
	elseif (x <= -5.1e-84)
		tmp = Float64(Float64(y * Float64(x * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t))));
	elseif (x <= 4.8e-226)
		tmp = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	elseif (x <= 1.85e-84)
		tmp = Float64(Float64(0.0 - Float64(i * Float64(y * j))) - Float64(b * Float64(z * c)));
	elseif (x <= 3.75e+115)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(i * Float64(b * a)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -6.5e+161)
		tmp = t_1;
	elseif (x <= -5.1e-84)
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	elseif (x <= 4.8e-226)
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	elseif (x <= 1.85e-84)
		tmp = (0.0 - (i * (y * j))) - (b * (z * c));
	elseif (x <= 3.75e+115)
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -6.5e+161], t$95$1, If[LessEqual[x, -5.1e-84], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.8e-226], N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.85e-84], N[(N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.75e+115], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -6.5e161 or 3.7499999999999998e115 < x

   1. Initial program 65.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -6.5e161 < x < -5.0999999999999996e-84

   1. Initial program 78.7%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -5.0999999999999996e-84 < x < 4.7999999999999999e-226

   1. Initial program 69.7%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 4.7999999999999999e-226 < x < 1.85e-84

   1. Initial program 69.5%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.85e-84 < x < 3.7499999999999998e115

   1. Initial program 84.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 13: 50.2% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -1.35 \cdot 10^{+34}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -2.4 \cdot 10^{-183}:\\ \;\;\;\;y \cdot \left(x \cdot z - \frac{x \cdot \left(a \cdot t\right)}{y}\right)\\ \mathbf{elif}\;j \leq 2.2 \cdot 10^{-222}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 7.5 \cdot 10^{-117}:\\ \;\;\;\;\left(x \cdot z\right) \cdot \left(y - \frac{b \cdot c}{x}\right)\\ \mathbf{elif}\;j \leq 2.9 \cdot 10^{+14}:\\ \;\;\;\;\left(t \cdot b\right) \cdot \left(\frac{j \cdot c}{b} - \frac{x \cdot a}{b}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* t c) (* y i)))))
   (if (<= j -1.35e+34)
     t_1
     (if (<= j -2.4e-183)
       (* y (- (* x z) (/ (* x (* a t)) y)))
       (if (<= j 2.2e-222)
         (* b (- (* a i) (* z c)))
         (if (<= j 7.5e-117)
           (* (* x z) (- y (/ (* b c) x)))
           (if (<= j 2.9e+14)
             (* (* t b) (- (/ (* j c) b) (/ (* x a) b)))
             t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.35e+34) {
		tmp = t_1;
	} else if (j <= -2.4e-183) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (j <= 2.2e-222) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 7.5e-117) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 2.9e+14) {
		tmp = (t * b) * (((j * c) / b) - ((x * a) / b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = j * ((t * c) - (y * i))
    if (j <= (-1.35d+34)) then
        tmp = t_1
    else if (j <= (-2.4d-183)) then
        tmp = y * ((x * z) - ((x * (a * t)) / y))
    else if (j <= 2.2d-222) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 7.5d-117) then
        tmp = (x * z) * (y - ((b * c) / x))
    else if (j <= 2.9d+14) then
        tmp = (t * b) * (((j * c) / b) - ((x * a) / b))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.35e+34) {
		tmp = t_1;
	} else if (j <= -2.4e-183) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (j <= 2.2e-222) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 7.5e-117) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 2.9e+14) {
		tmp = (t * b) * (((j * c) / b) - ((x * a) / b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -1.35e+34:
		tmp = t_1
	elif j <= -2.4e-183:
		tmp = y * ((x * z) - ((x * (a * t)) / y))
	elif j <= 2.2e-222:
		tmp = b * ((a * i) - (z * c))
	elif j <= 7.5e-117:
		tmp = (x * z) * (y - ((b * c) / x))
	elif j <= 2.9e+14:
		tmp = (t * b) * (((j * c) / b) - ((x * a) / b))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -1.35e+34)
		tmp = t_1;
	elseif (j <= -2.4e-183)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(Float64(x * Float64(a * t)) / y)));
	elseif (j <= 2.2e-222)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 7.5e-117)
		tmp = Float64(Float64(x * z) * Float64(y - Float64(Float64(b * c) / x)));
	elseif (j <= 2.9e+14)
		tmp = Float64(Float64(t * b) * Float64(Float64(Float64(j * c) / b) - Float64(Float64(x * a) / b)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -1.35e+34)
		tmp = t_1;
	elseif (j <= -2.4e-183)
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	elseif (j <= 2.2e-222)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 7.5e-117)
		tmp = (x * z) * (y - ((b * c) / x));
	elseif (j <= 2.9e+14)
		tmp = (t * b) * (((j * c) / b) - ((x * a) / b));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.35e+34], t$95$1, If[LessEqual[j, -2.4e-183], N[(y * N[(N[(x * z), $MachinePrecision] - N[(N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.2e-222], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.5e-117], N[(N[(x * z), $MachinePrecision] * N[(y - N[(N[(b * c), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.9e+14], N[(N[(t * b), $MachinePrecision] * N[(N[(N[(j * c), $MachinePrecision] / b), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -1.35e34 or 2.9e14 < j

   1. Initial program 68.1%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.35e34 < j < -2.39999999999999993e-183

   1. Initial program 81.9%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.39999999999999993e-183 < j < 2.2e-222

   1. Initial program 79.1%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.2e-222 < j < 7.50000000000000066e-117

   1. Initial program 62.6%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 7.50000000000000066e-117 < j < 2.9e14

   1. Initial program 77.6%

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

   3. Taylor expanded in b around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 14: 68.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;j \leq -1.35 \cdot 10^{+34}:\\ \;\;\;\;a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{elif}\;j \leq -2.35 \cdot 10^{-281}:\\ \;\;\;\;x \cdot \left(y \cdot z - a \cdot t\right) + t\_1\\ \mathbf{elif}\;j \leq 1.5 \cdot 10^{+69}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + \left(z \cdot \left(y \cdot x\right) + t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + c \cdot \left(j \cdot t - z \cdot b\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* b (- (* a i) (* z c)))))
   (if (<= j -1.35e+34)
     (+ (* a (* i b)) (* j (- (* c t) (* i y))))
     (if (<= j -2.35e-281)
       (+ (* x (- (* y z) (* a t))) t_1)
       (if (<= j 1.5e+69)
         (+ (* t (- (* j c) (* x a))) (+ (* z (* y x)) t_1))
         (+ (* y (- (* x z) (* i j))) (* c (- (* j t) (* z b)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (j <= -1.35e+34) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (j <= -2.35e-281) {
		tmp = (x * ((y * z) - (a * t))) + t_1;
	} else if (j <= 1.5e+69) {
		tmp = (t * ((j * c) - (x * a))) + ((z * (y * x)) + t_1);
	} else {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    if (j <= (-1.35d+34)) then
        tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
    else if (j <= (-2.35d-281)) then
        tmp = (x * ((y * z) - (a * t))) + t_1
    else if (j <= 1.5d+69) then
        tmp = (t * ((j * c) - (x * a))) + ((z * (y * x)) + t_1)
    else
        tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (j <= -1.35e+34) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (j <= -2.35e-281) {
		tmp = (x * ((y * z) - (a * t))) + t_1;
	} else if (j <= 1.5e+69) {
		tmp = (t * ((j * c) - (x * a))) + ((z * (y * x)) + t_1);
	} else {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	tmp = 0
	if j <= -1.35e+34:
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
	elif j <= -2.35e-281:
		tmp = (x * ((y * z) - (a * t))) + t_1
	elif j <= 1.5e+69:
		tmp = (t * ((j * c) - (x * a))) + ((z * (y * x)) + t_1)
	else:
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	tmp = 0.0
	if (j <= -1.35e+34)
		tmp = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	elseif (j <= -2.35e-281)
		tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(a * t))) + t_1);
	elseif (j <= 1.5e+69)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(Float64(z * Float64(y * x)) + t_1));
	else
		tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(c * Float64(Float64(j * t) - Float64(z * b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = b * ((a * i) - (z * c));
	tmp = 0.0;
	if (j <= -1.35e+34)
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	elseif (j <= -2.35e-281)
		tmp = (x * ((y * z) - (a * t))) + t_1;
	elseif (j <= 1.5e+69)
		tmp = (t * ((j * c) - (x * a))) + ((z * (y * x)) + t_1);
	else
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.35e+34], N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -2.35e-281], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[j, 1.5e+69], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(y * x), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(j * t), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if j < -1.35e34

   1. Initial program 69.4%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.35e34 < j < -2.3500000000000001e-281

   1. Initial program 79.9%

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

   3. Taylor expanded in j around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.3500000000000001e-281 < j < 1.49999999999999992e69

   1. Initial program 73.7%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.49999999999999992e69 < j

   1. Initial program 64.4%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 15: 49.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z - a \cdot t\right)\\ t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -1.5 \cdot 10^{+172}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;j \leq -1.08 \cdot 10^{-213}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 9.5 \cdot 10^{-175}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 8.5 \cdot 10^{-117}:\\ \;\;\;\;y \cdot \left(x \cdot z - j \cdot i\right)\\ \mathbf{elif}\;j \leq 4.8 \cdot 10^{-86}:\\ \;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\ \mathbf{elif}\;j \leq 3.3 \cdot 10^{+26}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* x (- (* y z) (* a t)))) (t_2 (* j (- (* t c) (* y i)))))
   (if (<= j -1.5e+172)
     t_2
     (if (<= j -1.08e-213)
       t_1
       (if (<= j 9.5e-175)
         (* b (- (* a i) (* z c)))
         (if (<= j 8.5e-117)
           (* y (- (* x z) (* j i)))
           (if (<= j 4.8e-86)
             (* i (- (* a b) (* y j)))
             (if (<= j 3.3e+26) t_1 t_2))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double t_2 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.5e+172) {
		tmp = t_2;
	} else if (j <= -1.08e-213) {
		tmp = t_1;
	} else if (j <= 9.5e-175) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 8.5e-117) {
		tmp = y * ((x * z) - (j * i));
	} else if (j <= 4.8e-86) {
		tmp = i * ((a * b) - (y * j));
	} else if (j <= 3.3e+26) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x * ((y * z) - (a * t))
    t_2 = j * ((t * c) - (y * i))
    if (j <= (-1.5d+172)) then
        tmp = t_2
    else if (j <= (-1.08d-213)) then
        tmp = t_1
    else if (j <= 9.5d-175) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 8.5d-117) then
        tmp = y * ((x * z) - (j * i))
    else if (j <= 4.8d-86) then
        tmp = i * ((a * b) - (y * j))
    else if (j <= 3.3d+26) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double t_2 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.5e+172) {
		tmp = t_2;
	} else if (j <= -1.08e-213) {
		tmp = t_1;
	} else if (j <= 9.5e-175) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 8.5e-117) {
		tmp = y * ((x * z) - (j * i));
	} else if (j <= 4.8e-86) {
		tmp = i * ((a * b) - (y * j));
	} else if (j <= 3.3e+26) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = x * ((y * z) - (a * t))
	t_2 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -1.5e+172:
		tmp = t_2
	elif j <= -1.08e-213:
		tmp = t_1
	elif j <= 9.5e-175:
		tmp = b * ((a * i) - (z * c))
	elif j <= 8.5e-117:
		tmp = y * ((x * z) - (j * i))
	elif j <= 4.8e-86:
		tmp = i * ((a * b) - (y * j))
	elif j <= 3.3e+26:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -1.5e+172)
		tmp = t_2;
	elseif (j <= -1.08e-213)
		tmp = t_1;
	elseif (j <= 9.5e-175)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 8.5e-117)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(j * i)));
	elseif (j <= 4.8e-86)
		tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j)));
	elseif (j <= 3.3e+26)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = x * ((y * z) - (a * t));
	t_2 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -1.5e+172)
		tmp = t_2;
	elseif (j <= -1.08e-213)
		tmp = t_1;
	elseif (j <= 9.5e-175)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 8.5e-117)
		tmp = y * ((x * z) - (j * i));
	elseif (j <= 4.8e-86)
		tmp = i * ((a * b) - (y * j));
	elseif (j <= 3.3e+26)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.5e+172], t$95$2, If[LessEqual[j, -1.08e-213], t$95$1, If[LessEqual[j, 9.5e-175], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 8.5e-117], N[(y * N[(N[(x * z), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 4.8e-86], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 3.3e+26], t$95$1, t$95$2]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -1.5e172 or 3.29999999999999993e26 < j

   1. Initial program 69.0%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.5e172 < j < -1.08e-213 or 4.80000000000000026e-86 < j < 3.29999999999999993e26

   1. Initial program 75.7%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.08e-213 < j < 9.50000000000000052e-175

   1. Initial program 78.2%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 9.50000000000000052e-175 < j < 8.49999999999999981e-117

   1. Initial program 48.0%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 8.49999999999999981e-117 < j < 4.80000000000000026e-86

   1. Initial program 73.3%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 16: 65.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := t \cdot \left(j \cdot c - x \cdot a\right)\\ \mathbf{if}\;j \leq -1.7 \cdot 10^{+34}:\\ \;\;\;\;a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{elif}\;j \leq 7 \cdot 10^{-222}:\\ \;\;\;\;x \cdot \left(y \cdot z - a \cdot t\right) + t\_1\\ \mathbf{elif}\;j \leq 3.4 \cdot 10^{-8}:\\ \;\;\;\;t\_2 + \left(z \cdot \left(y \cdot x\right) + c \cdot \left(b \cdot \left(0 - z\right)\right)\right)\\ \mathbf{elif}\;j \leq 10^{+69}:\\ \;\;\;\;t\_2 + t\_1\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + c \cdot \left(j \cdot t - z \cdot b\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* b (- (* a i) (* z c)))) (t_2 (* t (- (* j c) (* x a)))))
   (if (<= j -1.7e+34)
     (+ (* a (* i b)) (* j (- (* c t) (* i y))))
     (if (<= j 7e-222)
       (+ (* x (- (* y z) (* a t))) t_1)
       (if (<= j 3.4e-8)
         (+ t_2 (+ (* z (* y x)) (* c (* b (- 0.0 z)))))
         (if (<= j 1e+69)
           (+ t_2 t_1)
           (+ (* y (- (* x z) (* i j))) (* c (- (* j t) (* z b))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = t * ((j * c) - (x * a));
	double tmp;
	if (j <= -1.7e+34) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (j <= 7e-222) {
		tmp = (x * ((y * z) - (a * t))) + t_1;
	} else if (j <= 3.4e-8) {
		tmp = t_2 + ((z * (y * x)) + (c * (b * (0.0 - z))));
	} else if (j <= 1e+69) {
		tmp = t_2 + t_1;
	} else {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    t_2 = t * ((j * c) - (x * a))
    if (j <= (-1.7d+34)) then
        tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
    else if (j <= 7d-222) then
        tmp = (x * ((y * z) - (a * t))) + t_1
    else if (j <= 3.4d-8) then
        tmp = t_2 + ((z * (y * x)) + (c * (b * (0.0d0 - z))))
    else if (j <= 1d+69) then
        tmp = t_2 + t_1
    else
        tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = t * ((j * c) - (x * a));
	double tmp;
	if (j <= -1.7e+34) {
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	} else if (j <= 7e-222) {
		tmp = (x * ((y * z) - (a * t))) + t_1;
	} else if (j <= 3.4e-8) {
		tmp = t_2 + ((z * (y * x)) + (c * (b * (0.0 - z))));
	} else if (j <= 1e+69) {
		tmp = t_2 + t_1;
	} else {
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	t_2 = t * ((j * c) - (x * a))
	tmp = 0
	if j <= -1.7e+34:
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)))
	elif j <= 7e-222:
		tmp = (x * ((y * z) - (a * t))) + t_1
	elif j <= 3.4e-8:
		tmp = t_2 + ((z * (y * x)) + (c * (b * (0.0 - z))))
	elif j <= 1e+69:
		tmp = t_2 + t_1
	else:
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	t_2 = Float64(t * Float64(Float64(j * c) - Float64(x * a)))
	tmp = 0.0
	if (j <= -1.7e+34)
		tmp = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	elseif (j <= 7e-222)
		tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(a * t))) + t_1);
	elseif (j <= 3.4e-8)
		tmp = Float64(t_2 + Float64(Float64(z * Float64(y * x)) + Float64(c * Float64(b * Float64(0.0 - z)))));
	elseif (j <= 1e+69)
		tmp = Float64(t_2 + t_1);
	else
		tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(c * Float64(Float64(j * t) - Float64(z * b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = b * ((a * i) - (z * c));
	t_2 = t * ((j * c) - (x * a));
	tmp = 0.0;
	if (j <= -1.7e+34)
		tmp = (a * (i * b)) + (j * ((c * t) - (i * y)));
	elseif (j <= 7e-222)
		tmp = (x * ((y * z) - (a * t))) + t_1;
	elseif (j <= 3.4e-8)
		tmp = t_2 + ((z * (y * x)) + (c * (b * (0.0 - z))));
	elseif (j <= 1e+69)
		tmp = t_2 + t_1;
	else
		tmp = (y * ((x * z) - (i * j))) + (c * ((j * t) - (z * b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.7e+34], N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7e-222], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[j, 3.4e-8], N[(t$95$2 + N[(N[(z * N[(y * x), $MachinePrecision]), $MachinePrecision] + N[(c * N[(b * N[(0.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1e+69], N[(t$95$2 + t$95$1), $MachinePrecision], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(j * t), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -1.7e34

   1. Initial program 69.4%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.7e34 < j < 7.00000000000000049e-222

   1. Initial program 80.5%

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

   3. Taylor expanded in j around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 7.00000000000000049e-222 < j < 3.4e-8

   1. Initial program 67.6%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 3.4e-8 < j < 1.0000000000000001e69

   1. Initial program 82.3%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.0000000000000001e69 < j

   1. Initial program 64.4%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 17: 76.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -2.9 \cdot 10^{+217}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x \leq 5.2 \cdot 10^{+151}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + \left(y \cdot \left(x \cdot z - j \cdot i\right) + t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2 + t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* b (- (* a i) (* z c)))) (t_2 (* x (- (* y z) (* a t)))))
   (if (<= x -2.9e+217)
     t_2
     (if (<= x 5.2e+151)
       (+ (* t (- (* j c) (* x a))) (+ (* y (- (* x z) (* j i))) t_1))
       (+ t_2 t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -2.9e+217) {
		tmp = t_2;
	} else if (x <= 5.2e+151) {
		tmp = (t * ((j * c) - (x * a))) + ((y * ((x * z) - (j * i))) + t_1);
	} else {
		tmp = t_2 + t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    t_2 = x * ((y * z) - (a * t))
    if (x <= (-2.9d+217)) then
        tmp = t_2
    else if (x <= 5.2d+151) then
        tmp = (t * ((j * c) - (x * a))) + ((y * ((x * z) - (j * i))) + t_1)
    else
        tmp = t_2 + t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -2.9e+217) {
		tmp = t_2;
	} else if (x <= 5.2e+151) {
		tmp = (t * ((j * c) - (x * a))) + ((y * ((x * z) - (j * i))) + t_1);
	} else {
		tmp = t_2 + t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	t_2 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -2.9e+217:
		tmp = t_2
	elif x <= 5.2e+151:
		tmp = (t * ((j * c) - (x * a))) + ((y * ((x * z) - (j * i))) + t_1)
	else:
		tmp = t_2 + t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	t_2 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -2.9e+217)
		tmp = t_2;
	elseif (x <= 5.2e+151)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(Float64(y * Float64(Float64(x * z) - Float64(j * i))) + t_1));
	else
		tmp = Float64(t_2 + t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = b * ((a * i) - (z * c));
	t_2 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -2.9e+217)
		tmp = t_2;
	elseif (x <= 5.2e+151)
		tmp = (t * ((j * c) - (x * a))) + ((y * ((x * z) - (j * i))) + t_1);
	else
		tmp = t_2 + t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.9e+217], t$95$2, If[LessEqual[x, 5.2e+151], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(t$95$2 + t$95$1), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -2.89999999999999985e217

   1. Initial program 57.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.89999999999999985e217 < x < 5.20000000000000026e151

   1. Initial program 75.0%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 5.20000000000000026e151 < x

   1. Initial program 66.7%

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

   3. Taylor expanded in j around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 18: 59.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{if}\;x \leq -3.5 \cdot 10^{+160}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -9 \cdot 10^{-96}:\\ \;\;\;\;y \cdot \left(x \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;x \leq 1.8 \cdot 10^{-84}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right) - i \cdot \left(y \cdot j\right)\\ \mathbf{elif}\;x \leq 3.6 \cdot 10^{+116}:\\ \;\;\;\;t \cdot \left(j \cdot c - x \cdot a\right) + i \cdot \left(b \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* x (- (* y z) (* a t)))))
   (if (<= x -3.5e+160)
     t_1
     (if (<= x -9e-96)
       (+ (* y (* x z)) (* a (- (* b i) (* x t))))
       (if (<= x 1.8e-84)
         (- (* c (- (* t j) (* z b))) (* i (* y j)))
         (if (<= x 3.6e+116)
           (+ (* t (- (* j c) (* x a))) (* i (* b a)))
           t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -3.5e+160) {
		tmp = t_1;
	} else if (x <= -9e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= 1.8e-84) {
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	} else if (x <= 3.6e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = x * ((y * z) - (a * t))
    if (x <= (-3.5d+160)) then
        tmp = t_1
    else if (x <= (-9d-96)) then
        tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
    else if (x <= 1.8d-84) then
        tmp = (c * ((t * j) - (z * b))) - (i * (y * j))
    else if (x <= 3.6d+116) then
        tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = x * ((y * z) - (a * t));
	double tmp;
	if (x <= -3.5e+160) {
		tmp = t_1;
	} else if (x <= -9e-96) {
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	} else if (x <= 1.8e-84) {
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	} else if (x <= 3.6e+116) {
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = x * ((y * z) - (a * t))
	tmp = 0
	if x <= -3.5e+160:
		tmp = t_1
	elif x <= -9e-96:
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)))
	elif x <= 1.8e-84:
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j))
	elif x <= 3.6e+116:
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(x * Float64(Float64(y * z) - Float64(a * t)))
	tmp = 0.0
	if (x <= -3.5e+160)
		tmp = t_1;
	elseif (x <= -9e-96)
		tmp = Float64(Float64(y * Float64(x * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t))));
	elseif (x <= 1.8e-84)
		tmp = Float64(Float64(c * Float64(Float64(t * j) - Float64(z * b))) - Float64(i * Float64(y * j)));
	elseif (x <= 3.6e+116)
		tmp = Float64(Float64(t * Float64(Float64(j * c) - Float64(x * a))) + Float64(i * Float64(b * a)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = x * ((y * z) - (a * t));
	tmp = 0.0;
	if (x <= -3.5e+160)
		tmp = t_1;
	elseif (x <= -9e-96)
		tmp = (y * (x * z)) + (a * ((b * i) - (x * t)));
	elseif (x <= 1.8e-84)
		tmp = (c * ((t * j) - (z * b))) - (i * (y * j));
	elseif (x <= 3.6e+116)
		tmp = (t * ((j * c) - (x * a))) + (i * (b * a));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.5e+160], t$95$1, If[LessEqual[x, -9e-96], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.8e-84], N[(N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.6e+116], N[(N[(t * N[(N[(j * c), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if x < -3.50000000000000026e160 or 3.59999999999999971e116 < x

   1. Initial program 65.3%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.50000000000000026e160 < x < -9e-96

   1. Initial program 79.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -9e-96 < x < 1.80000000000000002e-84

   1. Initial program 69.3%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.80000000000000002e-84 < x < 3.59999999999999971e116

   1. Initial program 84.1%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 19: 51.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -1.52 \cdot 10^{+34}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -3.6 \cdot 10^{-186}:\\ \;\;\;\;y \cdot \left(x \cdot z - \frac{x \cdot \left(a \cdot t\right)}{y}\right)\\ \mathbf{elif}\;j \leq 5.8 \cdot 10^{-225}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 4.4 \cdot 10^{-129}:\\ \;\;\;\;\left(x \cdot z\right) \cdot \left(y - \frac{b \cdot c}{x}\right)\\ \mathbf{elif}\;j \leq 1.15 \cdot 10^{+15}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* t c) (* y i)))))
   (if (<= j -1.52e+34)
     t_1
     (if (<= j -3.6e-186)
       (* y (- (* x z) (/ (* x (* a t)) y)))
       (if (<= j 5.8e-225)
         (* b (- (* a i) (* z c)))
         (if (<= j 4.4e-129)
           (* (* x z) (- y (/ (* b c) x)))
           (if (<= j 1.15e+15) (* a (- (* i b) (* x t))) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.52e+34) {
		tmp = t_1;
	} else if (j <= -3.6e-186) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (j <= 5.8e-225) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 4.4e-129) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 1.15e+15) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = j * ((t * c) - (y * i))
    if (j <= (-1.52d+34)) then
        tmp = t_1
    else if (j <= (-3.6d-186)) then
        tmp = y * ((x * z) - ((x * (a * t)) / y))
    else if (j <= 5.8d-225) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 4.4d-129) then
        tmp = (x * z) * (y - ((b * c) / x))
    else if (j <= 1.15d+15) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.52e+34) {
		tmp = t_1;
	} else if (j <= -3.6e-186) {
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	} else if (j <= 5.8e-225) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 4.4e-129) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 1.15e+15) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -1.52e+34:
		tmp = t_1
	elif j <= -3.6e-186:
		tmp = y * ((x * z) - ((x * (a * t)) / y))
	elif j <= 5.8e-225:
		tmp = b * ((a * i) - (z * c))
	elif j <= 4.4e-129:
		tmp = (x * z) * (y - ((b * c) / x))
	elif j <= 1.15e+15:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -1.52e+34)
		tmp = t_1;
	elseif (j <= -3.6e-186)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(Float64(x * Float64(a * t)) / y)));
	elseif (j <= 5.8e-225)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 4.4e-129)
		tmp = Float64(Float64(x * z) * Float64(y - Float64(Float64(b * c) / x)));
	elseif (j <= 1.15e+15)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -1.52e+34)
		tmp = t_1;
	elseif (j <= -3.6e-186)
		tmp = y * ((x * z) - ((x * (a * t)) / y));
	elseif (j <= 5.8e-225)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 4.4e-129)
		tmp = (x * z) * (y - ((b * c) / x));
	elseif (j <= 1.15e+15)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.52e+34], t$95$1, If[LessEqual[j, -3.6e-186], N[(y * N[(N[(x * z), $MachinePrecision] - N[(N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 5.8e-225], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 4.4e-129], N[(N[(x * z), $MachinePrecision] * N[(y - N[(N[(b * c), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.15e+15], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -1.52000000000000001e34 or 1.15e15 < j

   1. Initial program 68.1%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.52000000000000001e34 < j < -3.5999999999999998e-186

   1. Initial program 81.9%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -3.5999999999999998e-186 < j < 5.7999999999999996e-225

   1. Initial program 79.1%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 5.7999999999999996e-225 < j < 4.40000000000000006e-129

   1. Initial program 66.0%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 4.40000000000000006e-129 < j < 1.15e15

   1. Initial program 73.7%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 20: 49.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -1.75 \cdot 10^{+172}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -3.8 \cdot 10^{-214}:\\ \;\;\;\;x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{elif}\;j \leq 4.2 \cdot 10^{-222}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 9.2 \cdot 10^{-129}:\\ \;\;\;\;\left(x \cdot z\right) \cdot \left(y - \frac{b \cdot c}{x}\right)\\ \mathbf{elif}\;j \leq 2.05 \cdot 10^{+15}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* t c) (* y i)))))
   (if (<= j -1.75e+172)
     t_1
     (if (<= j -3.8e-214)
       (* x (- (* y z) (* a t)))
       (if (<= j 4.2e-222)
         (* b (- (* a i) (* z c)))
         (if (<= j 9.2e-129)
           (* (* x z) (- y (/ (* b c) x)))
           (if (<= j 2.05e+15) (* a (- (* i b) (* x t))) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.75e+172) {
		tmp = t_1;
	} else if (j <= -3.8e-214) {
		tmp = x * ((y * z) - (a * t));
	} else if (j <= 4.2e-222) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 9.2e-129) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 2.05e+15) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = j * ((t * c) - (y * i))
    if (j <= (-1.75d+172)) then
        tmp = t_1
    else if (j <= (-3.8d-214)) then
        tmp = x * ((y * z) - (a * t))
    else if (j <= 4.2d-222) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 9.2d-129) then
        tmp = (x * z) * (y - ((b * c) / x))
    else if (j <= 2.05d+15) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.75e+172) {
		tmp = t_1;
	} else if (j <= -3.8e-214) {
		tmp = x * ((y * z) - (a * t));
	} else if (j <= 4.2e-222) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 9.2e-129) {
		tmp = (x * z) * (y - ((b * c) / x));
	} else if (j <= 2.05e+15) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -1.75e+172:
		tmp = t_1
	elif j <= -3.8e-214:
		tmp = x * ((y * z) - (a * t))
	elif j <= 4.2e-222:
		tmp = b * ((a * i) - (z * c))
	elif j <= 9.2e-129:
		tmp = (x * z) * (y - ((b * c) / x))
	elif j <= 2.05e+15:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -1.75e+172)
		tmp = t_1;
	elseif (j <= -3.8e-214)
		tmp = Float64(x * Float64(Float64(y * z) - Float64(a * t)));
	elseif (j <= 4.2e-222)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 9.2e-129)
		tmp = Float64(Float64(x * z) * Float64(y - Float64(Float64(b * c) / x)));
	elseif (j <= 2.05e+15)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -1.75e+172)
		tmp = t_1;
	elseif (j <= -3.8e-214)
		tmp = x * ((y * z) - (a * t));
	elseif (j <= 4.2e-222)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 9.2e-129)
		tmp = (x * z) * (y - ((b * c) / x));
	elseif (j <= 2.05e+15)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.75e+172], t$95$1, If[LessEqual[j, -3.8e-214], N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 4.2e-222], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 9.2e-129], N[(N[(x * z), $MachinePrecision] * N[(y - N[(N[(b * c), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.05e+15], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -1.74999999999999989e172 or 2.05e15 < j

   1. Initial program 69.0%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.74999999999999989e172 < j < -3.8000000000000003e-214

   1. Initial program 74.9%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.8000000000000003e-214 < j < 4.1999999999999998e-222

   1. Initial program 79.5%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 4.1999999999999998e-222 < j < 9.1999999999999998e-129

   1. Initial program 66.0%

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

   3. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 9.1999999999999998e-129 < j < 2.05e15

   1. Initial program 73.7%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 21: 49.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -3.4 \cdot 10^{+137}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -5.2 \cdot 10^{-33}:\\ \;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\ \mathbf{elif}\;j \leq -7.5 \cdot 10^{-104}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;j \leq 7.2 \cdot 10^{-172}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 6.8 \cdot 10^{+14}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* t c) (* y i)))))
   (if (<= j -3.4e+137)
     t_1
     (if (<= j -5.2e-33)
       (* i (- (* a b) (* y j)))
       (if (<= j -7.5e-104)
         (* y (* x z))
         (if (<= j 7.2e-172)
           (* b (- (* a i) (* z c)))
           (if (<= j 6.8e+14) (* a (- (* i b) (* x t))) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -3.4e+137) {
		tmp = t_1;
	} else if (j <= -5.2e-33) {
		tmp = i * ((a * b) - (y * j));
	} else if (j <= -7.5e-104) {
		tmp = y * (x * z);
	} else if (j <= 7.2e-172) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 6.8e+14) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = j * ((t * c) - (y * i))
    if (j <= (-3.4d+137)) then
        tmp = t_1
    else if (j <= (-5.2d-33)) then
        tmp = i * ((a * b) - (y * j))
    else if (j <= (-7.5d-104)) then
        tmp = y * (x * z)
    else if (j <= 7.2d-172) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 6.8d+14) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -3.4e+137) {
		tmp = t_1;
	} else if (j <= -5.2e-33) {
		tmp = i * ((a * b) - (y * j));
	} else if (j <= -7.5e-104) {
		tmp = y * (x * z);
	} else if (j <= 7.2e-172) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 6.8e+14) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -3.4e+137:
		tmp = t_1
	elif j <= -5.2e-33:
		tmp = i * ((a * b) - (y * j))
	elif j <= -7.5e-104:
		tmp = y * (x * z)
	elif j <= 7.2e-172:
		tmp = b * ((a * i) - (z * c))
	elif j <= 6.8e+14:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -3.4e+137)
		tmp = t_1;
	elseif (j <= -5.2e-33)
		tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j)));
	elseif (j <= -7.5e-104)
		tmp = Float64(y * Float64(x * z));
	elseif (j <= 7.2e-172)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 6.8e+14)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -3.4e+137)
		tmp = t_1;
	elseif (j <= -5.2e-33)
		tmp = i * ((a * b) - (y * j));
	elseif (j <= -7.5e-104)
		tmp = y * (x * z);
	elseif (j <= 7.2e-172)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 6.8e+14)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -3.4e+137], t$95$1, If[LessEqual[j, -5.2e-33], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -7.5e-104], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.2e-172], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 6.8e+14], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -3.39999999999999986e137 or 6.8e14 < j

   1. Initial program 68.8%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.39999999999999986e137 < j < -5.19999999999999988e-33

   1. Initial program 74.0%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -5.19999999999999988e-33 < j < -7.5e-104

   1. Initial program 82.3%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -7.5e-104 < j < 7.20000000000000029e-172

   1. Initial program 76.3%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 7.20000000000000029e-172 < j < 6.8e14

   1. Initial program 70.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 22: 40.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j\right)\\ \mathbf{if}\;j \leq -2.5 \cdot 10^{+142}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -2.4 \cdot 10^{+95}:\\ \;\;\;\;0 - i \cdot \left(y \cdot j\right)\\ \mathbf{elif}\;j \leq 7.5 \cdot 10^{+15}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{elif}\;j \leq 1.35 \cdot 10^{+54}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;j \leq 2 \cdot 10^{+190}:\\ \;\;\;\;y \cdot \left(j \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* c (* t j))))
   (if (<= j -2.5e+142)
     t_1
     (if (<= j -2.4e+95)
       (- 0.0 (* i (* y j)))
       (if (<= j 7.5e+15)
         (* a (- (* i b) (* x t)))
         (if (<= j 1.35e+54)
           (* j (* c t))
           (if (<= j 2e+190) (* y (* j (- i))) t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * (t * j);
	double tmp;
	if (j <= -2.5e+142) {
		tmp = t_1;
	} else if (j <= -2.4e+95) {
		tmp = 0.0 - (i * (y * j));
	} else if (j <= 7.5e+15) {
		tmp = a * ((i * b) - (x * t));
	} else if (j <= 1.35e+54) {
		tmp = j * (c * t);
	} else if (j <= 2e+190) {
		tmp = y * (j * -i);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = c * (t * j)
    if (j <= (-2.5d+142)) then
        tmp = t_1
    else if (j <= (-2.4d+95)) then
        tmp = 0.0d0 - (i * (y * j))
    else if (j <= 7.5d+15) then
        tmp = a * ((i * b) - (x * t))
    else if (j <= 1.35d+54) then
        tmp = j * (c * t)
    else if (j <= 2d+190) then
        tmp = y * (j * -i)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * (t * j);
	double tmp;
	if (j <= -2.5e+142) {
		tmp = t_1;
	} else if (j <= -2.4e+95) {
		tmp = 0.0 - (i * (y * j));
	} else if (j <= 7.5e+15) {
		tmp = a * ((i * b) - (x * t));
	} else if (j <= 1.35e+54) {
		tmp = j * (c * t);
	} else if (j <= 2e+190) {
		tmp = y * (j * -i);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * (t * j)
	tmp = 0
	if j <= -2.5e+142:
		tmp = t_1
	elif j <= -2.4e+95:
		tmp = 0.0 - (i * (y * j))
	elif j <= 7.5e+15:
		tmp = a * ((i * b) - (x * t))
	elif j <= 1.35e+54:
		tmp = j * (c * t)
	elif j <= 2e+190:
		tmp = y * (j * -i)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(t * j))
	tmp = 0.0
	if (j <= -2.5e+142)
		tmp = t_1;
	elseif (j <= -2.4e+95)
		tmp = Float64(0.0 - Float64(i * Float64(y * j)));
	elseif (j <= 7.5e+15)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	elseif (j <= 1.35e+54)
		tmp = Float64(j * Float64(c * t));
	elseif (j <= 2e+190)
		tmp = Float64(y * Float64(j * Float64(-i)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = c * (t * j);
	tmp = 0.0;
	if (j <= -2.5e+142)
		tmp = t_1;
	elseif (j <= -2.4e+95)
		tmp = 0.0 - (i * (y * j));
	elseif (j <= 7.5e+15)
		tmp = a * ((i * b) - (x * t));
	elseif (j <= 1.35e+54)
		tmp = j * (c * t);
	elseif (j <= 2e+190)
		tmp = y * (j * -i);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2.5e+142], t$95$1, If[LessEqual[j, -2.4e+95], N[(0.0 - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.5e+15], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.35e+54], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2e+190], N[(y * N[(j * (-i)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 5 regimes

2. if j < -2.5000000000000001e142 or 2.0000000000000001e190 < j

   1. Initial program 66.9%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.5000000000000001e142 < j < -2.4e95

   1. Initial program 59.3%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -2.4e95 < j < 7.5e15

   1. Initial program 75.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 7.5e15 < j < 1.35000000000000005e54

   1. Initial program 62.5%

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

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.35000000000000005e54 < j < 2.0000000000000001e190

   1. Initial program 74.9%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 23: 28.9% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -4.6 \cdot 10^{+135}:\\ \;\;\;\;\left(c \cdot j\right) \cdot t\\ \mathbf{elif}\;c \leq -14000:\\ \;\;\;\;-x \cdot \left(a \cdot t\right)\\ \mathbf{elif}\;c \leq 2.35 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 1.15 \cdot 10^{-85}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;c \leq 5.2 \cdot 10^{+129}:\\ \;\;\;\;y \cdot \left(j \cdot \left(-i\right)\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -4.6e+135)
   (* (* c j) t)
   (if (<= c -14000.0)
     (- (* x (* a t)))
     (if (<= c 2.35e-296)
       (* (* a i) b)
       (if (<= c 1.15e-85)
         (* y (* x z))
         (if (<= c 5.2e+129) (* y (* j (- i))) (* j (* c t))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -4.6e+135) {
		tmp = (c * j) * t;
	} else if (c <= -14000.0) {
		tmp = -(x * (a * t));
	} else if (c <= 2.35e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.15e-85) {
		tmp = y * (x * z);
	} else if (c <= 5.2e+129) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-4.6d+135)) then
        tmp = (c * j) * t
    else if (c <= (-14000.0d0)) then
        tmp = -(x * (a * t))
    else if (c <= 2.35d-296) then
        tmp = (a * i) * b
    else if (c <= 1.15d-85) then
        tmp = y * (x * z)
    else if (c <= 5.2d+129) then
        tmp = y * (j * -i)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -4.6e+135) {
		tmp = (c * j) * t;
	} else if (c <= -14000.0) {
		tmp = -(x * (a * t));
	} else if (c <= 2.35e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.15e-85) {
		tmp = y * (x * z);
	} else if (c <= 5.2e+129) {
		tmp = y * (j * -i);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -4.6e+135:
		tmp = (c * j) * t
	elif c <= -14000.0:
		tmp = -(x * (a * t))
	elif c <= 2.35e-296:
		tmp = (a * i) * b
	elif c <= 1.15e-85:
		tmp = y * (x * z)
	elif c <= 5.2e+129:
		tmp = y * (j * -i)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -4.6e+135)
		tmp = Float64(Float64(c * j) * t);
	elseif (c <= -14000.0)
		tmp = Float64(-Float64(x * Float64(a * t)));
	elseif (c <= 2.35e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 1.15e-85)
		tmp = Float64(y * Float64(x * z));
	elseif (c <= 5.2e+129)
		tmp = Float64(y * Float64(j * Float64(-i)));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -4.6e+135)
		tmp = (c * j) * t;
	elseif (c <= -14000.0)
		tmp = -(x * (a * t));
	elseif (c <= 2.35e-296)
		tmp = (a * i) * b;
	elseif (c <= 1.15e-85)
		tmp = y * (x * z);
	elseif (c <= 5.2e+129)
		tmp = y * (j * -i);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -4.6e+135], N[(N[(c * j), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[c, -14000.0], (-N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, 2.35e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 1.15e-85], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.2e+129], N[(y * N[(j * (-i)), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 6 regimes

2. if c < -4.6000000000000002e135

   1. Initial program 55.1%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -4.6000000000000002e135 < c < -14000

   1. Initial program 67.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -14000 < c < 2.35e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.35e-296 < c < 1.15e-85

   1. Initial program 77.8%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.15e-85 < c < 5.20000000000000024e129

   1. Initial program 73.0%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.20000000000000024e129 < c

   1. Initial program 66.0%

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

   3. Taylor expanded in y around 0 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 6 regimes into one program.
4. Add Preprocessing

Alternative 24: 50.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;j \leq -1.5 \cdot 10^{+172}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq -2.7 \cdot 10^{-214}:\\ \;\;\;\;x \cdot \left(y \cdot z - a \cdot t\right)\\ \mathbf{elif}\;j \leq 1.4 \cdot 10^{-171}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;j \leq 7.2 \cdot 10^{+14}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* t c) (* y i)))))
   (if (<= j -1.5e+172)
     t_1
     (if (<= j -2.7e-214)
       (* x (- (* y z) (* a t)))
       (if (<= j 1.4e-171)
         (* b (- (* a i) (* z c)))
         (if (<= j 7.2e+14) (* a (- (* i b) (* x t))) t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.5e+172) {
		tmp = t_1;
	} else if (j <= -2.7e-214) {
		tmp = x * ((y * z) - (a * t));
	} else if (j <= 1.4e-171) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 7.2e+14) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = j * ((t * c) - (y * i))
    if (j <= (-1.5d+172)) then
        tmp = t_1
    else if (j <= (-2.7d-214)) then
        tmp = x * ((y * z) - (a * t))
    else if (j <= 1.4d-171) then
        tmp = b * ((a * i) - (z * c))
    else if (j <= 7.2d+14) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double tmp;
	if (j <= -1.5e+172) {
		tmp = t_1;
	} else if (j <= -2.7e-214) {
		tmp = x * ((y * z) - (a * t));
	} else if (j <= 1.4e-171) {
		tmp = b * ((a * i) - (z * c));
	} else if (j <= 7.2e+14) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	tmp = 0
	if j <= -1.5e+172:
		tmp = t_1
	elif j <= -2.7e-214:
		tmp = x * ((y * z) - (a * t))
	elif j <= 1.4e-171:
		tmp = b * ((a * i) - (z * c))
	elif j <= 7.2e+14:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (j <= -1.5e+172)
		tmp = t_1;
	elseif (j <= -2.7e-214)
		tmp = Float64(x * Float64(Float64(y * z) - Float64(a * t)));
	elseif (j <= 1.4e-171)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (j <= 7.2e+14)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (j <= -1.5e+172)
		tmp = t_1;
	elseif (j <= -2.7e-214)
		tmp = x * ((y * z) - (a * t));
	elseif (j <= 1.4e-171)
		tmp = b * ((a * i) - (z * c));
	elseif (j <= 7.2e+14)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.5e+172], t$95$1, If[LessEqual[j, -2.7e-214], N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.4e-171], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.2e+14], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 4 regimes

2. if j < -1.5e172 or 7.2e14 < j

   1. Initial program 69.0%

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

   3. Taylor expanded in j around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.5e172 < j < -2.7000000000000001e-214

   1. Initial program 74.9%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.7000000000000001e-214 < j < 1.40000000000000011e-171

   1. Initial program 76.9%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.40000000000000011e-171 < j < 7.2e14

   1. Initial program 70.1%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 25: 68.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(i \cdot b\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;j \leq -1.7 \cdot 10^{+34}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 3.1 \cdot 10^{+25}:\\ \;\;\;\;x \cdot \left(y \cdot z - a \cdot t\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (+ (* a (* i b)) (* j (- (* c t) (* i y))))))
   (if (<= j -1.7e+34)
     t_1
     (if (<= j 3.1e+25)
       (+ (* x (- (* y z) (* a t))) (* b (- (* a i) (* z c))))
       t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double tmp;
	if (j <= -1.7e+34) {
		tmp = t_1;
	} else if (j <= 3.1e+25) {
		tmp = (x * ((y * z) - (a * t))) + (b * ((a * i) - (z * c)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
    if (j <= (-1.7d+34)) then
        tmp = t_1
    else if (j <= 3.1d+25) then
        tmp = (x * ((y * z) - (a * t))) + (b * ((a * i) - (z * c)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	double tmp;
	if (j <= -1.7e+34) {
		tmp = t_1;
	} else if (j <= 3.1e+25) {
		tmp = (x * ((y * z) - (a * t))) + (b * ((a * i) - (z * c)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)))
	tmp = 0
	if j <= -1.7e+34:
		tmp = t_1
	elif j <= 3.1e+25:
		tmp = (x * ((y * z) - (a * t))) + (b * ((a * i) - (z * c)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(a * Float64(i * b)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	tmp = 0.0
	if (j <= -1.7e+34)
		tmp = t_1;
	elseif (j <= 3.1e+25)
		tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(a * t))) + Float64(b * Float64(Float64(a * i) - Float64(z * c))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (a * (i * b)) + (j * ((c * t) - (i * y)));
	tmp = 0.0;
	if (j <= -1.7e+34)
		tmp = t_1;
	elseif (j <= 3.1e+25)
		tmp = (x * ((y * z) - (a * t))) + (b * ((a * i) - (z * c)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.7e+34], t$95$1, If[LessEqual[j, 3.1e+25], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if j < -1.7e34 or 3.0999999999999998e25 < j

   1. Initial program 68.1%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.7e34 < j < 3.0999999999999998e25

   1. Initial program 75.9%

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

   3. Taylor expanded in j around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 26: 29.6% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -2.8 \cdot 10^{+135}:\\ \;\;\;\;\left(c \cdot j\right) \cdot t\\ \mathbf{elif}\;c \leq -21000:\\ \;\;\;\;-x \cdot \left(a \cdot t\right)\\ \mathbf{elif}\;c \leq 3.5 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 5.2 \cdot 10^{+73}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -2.8e+135)
   (* (* c j) t)
   (if (<= c -21000.0)
     (- (* x (* a t)))
     (if (<= c 3.5e-296)
       (* (* a i) b)
       (if (<= c 5.2e+73) (* y (* x z)) (* j (* c t)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -2.8e+135) {
		tmp = (c * j) * t;
	} else if (c <= -21000.0) {
		tmp = -(x * (a * t));
	} else if (c <= 3.5e-296) {
		tmp = (a * i) * b;
	} else if (c <= 5.2e+73) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-2.8d+135)) then
        tmp = (c * j) * t
    else if (c <= (-21000.0d0)) then
        tmp = -(x * (a * t))
    else if (c <= 3.5d-296) then
        tmp = (a * i) * b
    else if (c <= 5.2d+73) then
        tmp = y * (x * z)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -2.8e+135) {
		tmp = (c * j) * t;
	} else if (c <= -21000.0) {
		tmp = -(x * (a * t));
	} else if (c <= 3.5e-296) {
		tmp = (a * i) * b;
	} else if (c <= 5.2e+73) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -2.8e+135:
		tmp = (c * j) * t
	elif c <= -21000.0:
		tmp = -(x * (a * t))
	elif c <= 3.5e-296:
		tmp = (a * i) * b
	elif c <= 5.2e+73:
		tmp = y * (x * z)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -2.8e+135)
		tmp = Float64(Float64(c * j) * t);
	elseif (c <= -21000.0)
		tmp = Float64(-Float64(x * Float64(a * t)));
	elseif (c <= 3.5e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 5.2e+73)
		tmp = Float64(y * Float64(x * z));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -2.8e+135)
		tmp = (c * j) * t;
	elseif (c <= -21000.0)
		tmp = -(x * (a * t));
	elseif (c <= 3.5e-296)
		tmp = (a * i) * b;
	elseif (c <= 5.2e+73)
		tmp = y * (x * z);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -2.8e+135], N[(N[(c * j), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[c, -21000.0], (-N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, 3.5e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 5.2e+73], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 5 regimes

2. if c < -2.80000000000000002e135

   1. Initial program 55.1%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -2.80000000000000002e135 < c < -21000

   1. Initial program 67.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -21000 < c < 3.4999999999999999e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 3.4999999999999999e-296 < c < 5.2000000000000001e73

   1. Initial program 78.1%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.2000000000000001e73 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 5 regimes into one program.
4. Add Preprocessing

Alternative 27: 50.9% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{if}\;c \leq -3.3 \cdot 10^{+61}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 5 \cdot 10^{-134}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{elif}\;c \leq 1.9 \cdot 10^{+130}:\\ \;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* c (- (* t j) (* z b)))))
   (if (<= c -3.3e+61)
     t_1
     (if (<= c 5e-134)
       (* a (- (* i b) (* x t)))
       (if (<= c 1.9e+130) (* i (- (* a b) (* y j))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -3.3e+61) {
		tmp = t_1;
	} else if (c <= 5e-134) {
		tmp = a * ((i * b) - (x * t));
	} else if (c <= 1.9e+130) {
		tmp = i * ((a * b) - (y * j));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = c * ((t * j) - (z * b))
    if (c <= (-3.3d+61)) then
        tmp = t_1
    else if (c <= 5d-134) then
        tmp = a * ((i * b) - (x * t))
    else if (c <= 1.9d+130) then
        tmp = i * ((a * b) - (y * j))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -3.3e+61) {
		tmp = t_1;
	} else if (c <= 5e-134) {
		tmp = a * ((i * b) - (x * t));
	} else if (c <= 1.9e+130) {
		tmp = i * ((a * b) - (y * j));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((t * j) - (z * b))
	tmp = 0
	if c <= -3.3e+61:
		tmp = t_1
	elif c <= 5e-134:
		tmp = a * ((i * b) - (x * t))
	elif c <= 1.9e+130:
		tmp = i * ((a * b) - (y * j))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b)))
	tmp = 0.0
	if (c <= -3.3e+61)
		tmp = t_1;
	elseif (c <= 5e-134)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	elseif (c <= 1.9e+130)
		tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = c * ((t * j) - (z * b));
	tmp = 0.0;
	if (c <= -3.3e+61)
		tmp = t_1;
	elseif (c <= 5e-134)
		tmp = a * ((i * b) - (x * t));
	elseif (c <= 1.9e+130)
		tmp = i * ((a * b) - (y * j));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.3e+61], t$95$1, If[LessEqual[c, 5e-134], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.9e+130], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if c < -3.2999999999999998e61 or 1.9000000000000001e130 < c

   1. Initial program 60.4%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.2999999999999998e61 < c < 5.0000000000000003e-134

   1. Initial program 80.3%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 5.0000000000000003e-134 < c < 1.9000000000000001e130

   1. Initial program 73.5%

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

   3. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 28: 30.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -16200:\\ \;\;\;\;\left(c \cdot j\right) \cdot t\\ \mathbf{elif}\;c \leq 4.1 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 1.9 \cdot 10^{+75}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -16200.0)
   (* (* c j) t)
   (if (<= c 4.1e-296)
     (* (* a i) b)
     (if (<= c 1.9e+75) (* y (* x z)) (* j (* c t))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -16200.0) {
		tmp = (c * j) * t;
	} else if (c <= 4.1e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.9e+75) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-16200.0d0)) then
        tmp = (c * j) * t
    else if (c <= 4.1d-296) then
        tmp = (a * i) * b
    else if (c <= 1.9d+75) then
        tmp = y * (x * z)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -16200.0) {
		tmp = (c * j) * t;
	} else if (c <= 4.1e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.9e+75) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -16200.0:
		tmp = (c * j) * t
	elif c <= 4.1e-296:
		tmp = (a * i) * b
	elif c <= 1.9e+75:
		tmp = y * (x * z)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -16200.0)
		tmp = Float64(Float64(c * j) * t);
	elseif (c <= 4.1e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 1.9e+75)
		tmp = Float64(y * Float64(x * z));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -16200.0)
		tmp = (c * j) * t;
	elseif (c <= 4.1e-296)
		tmp = (a * i) * b;
	elseif (c <= 1.9e+75)
		tmp = y * (x * z);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -16200.0], N[(N[(c * j), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[c, 4.1e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 1.9e+75], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if c < -16200

   1. Initial program 59.7%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if -16200 < c < 4.09999999999999994e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 4.09999999999999994e-296 < c < 1.9000000000000001e75

   1. Initial program 78.1%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.9000000000000001e75 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 4 regimes into one program.
4. Add Preprocessing

Alternative 29: 29.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -24000:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;c \leq 2.25 \cdot 10^{-296}:\\ \;\;\;\;\left(a \cdot i\right) \cdot b\\ \mathbf{elif}\;c \leq 1.5 \cdot 10^{+75}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -24000.0)
   (* c (* t j))
   (if (<= c 2.25e-296)
     (* (* a i) b)
     (if (<= c 1.5e+75) (* y (* x z)) (* j (* c t))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -24000.0) {
		tmp = c * (t * j);
	} else if (c <= 2.25e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.5e+75) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-24000.0d0)) then
        tmp = c * (t * j)
    else if (c <= 2.25d-296) then
        tmp = (a * i) * b
    else if (c <= 1.5d+75) then
        tmp = y * (x * z)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -24000.0) {
		tmp = c * (t * j);
	} else if (c <= 2.25e-296) {
		tmp = (a * i) * b;
	} else if (c <= 1.5e+75) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -24000.0:
		tmp = c * (t * j)
	elif c <= 2.25e-296:
		tmp = (a * i) * b
	elif c <= 1.5e+75:
		tmp = y * (x * z)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -24000.0)
		tmp = Float64(c * Float64(t * j));
	elseif (c <= 2.25e-296)
		tmp = Float64(Float64(a * i) * b);
	elseif (c <= 1.5e+75)
		tmp = Float64(y * Float64(x * z));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -24000.0)
		tmp = c * (t * j);
	elseif (c <= 2.25e-296)
		tmp = (a * i) * b;
	elseif (c <= 1.5e+75)
		tmp = y * (x * z);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -24000.0], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.25e-296], N[(N[(a * i), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 1.5e+75], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if c < -24000

   1. Initial program 59.7%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -24000 < c < 2.2500000000000001e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.2500000000000001e-296 < c < 1.5e75

   1. Initial program 78.1%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.5e75 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 4 regimes into one program.
4. Add Preprocessing

Alternative 30: 29.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -27000:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;c \leq 3.5 \cdot 10^{-296}:\\ \;\;\;\;i \cdot \left(b \cdot a\right)\\ \mathbf{elif}\;c \leq 5.1 \cdot 10^{+73}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -27000.0)
   (* c (* t j))
   (if (<= c 3.5e-296)
     (* i (* b a))
     (if (<= c 5.1e+73) (* y (* x z)) (* j (* c t))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -27000.0) {
		tmp = c * (t * j);
	} else if (c <= 3.5e-296) {
		tmp = i * (b * a);
	} else if (c <= 5.1e+73) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-27000.0d0)) then
        tmp = c * (t * j)
    else if (c <= 3.5d-296) then
        tmp = i * (b * a)
    else if (c <= 5.1d+73) then
        tmp = y * (x * z)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -27000.0) {
		tmp = c * (t * j);
	} else if (c <= 3.5e-296) {
		tmp = i * (b * a);
	} else if (c <= 5.1e+73) {
		tmp = y * (x * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -27000.0:
		tmp = c * (t * j)
	elif c <= 3.5e-296:
		tmp = i * (b * a)
	elif c <= 5.1e+73:
		tmp = y * (x * z)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -27000.0)
		tmp = Float64(c * Float64(t * j));
	elseif (c <= 3.5e-296)
		tmp = Float64(i * Float64(b * a));
	elseif (c <= 5.1e+73)
		tmp = Float64(y * Float64(x * z));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -27000.0)
		tmp = c * (t * j);
	elseif (c <= 3.5e-296)
		tmp = i * (b * a);
	elseif (c <= 5.1e+73)
		tmp = y * (x * z);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -27000.0], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.5e-296], N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.1e+73], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if c < -27000

   1. Initial program 59.7%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -27000 < c < 3.4999999999999999e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.4999999999999999e-296 < c < 5.10000000000000024e73

   1. Initial program 78.1%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.10000000000000024e73 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 4 regimes into one program.
4. Add Preprocessing

Alternative 31: 29.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -24000:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;c \leq 2.2 \cdot 10^{-296}:\\ \;\;\;\;i \cdot \left(b \cdot a\right)\\ \mathbf{elif}\;c \leq 6 \cdot 10^{+73}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -24000.0)
   (* c (* t j))
   (if (<= c 2.2e-296)
     (* i (* b a))
     (if (<= c 6e+73) (* x (* y z)) (* j (* c t))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -24000.0) {
		tmp = c * (t * j);
	} else if (c <= 2.2e-296) {
		tmp = i * (b * a);
	} else if (c <= 6e+73) {
		tmp = x * (y * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-24000.0d0)) then
        tmp = c * (t * j)
    else if (c <= 2.2d-296) then
        tmp = i * (b * a)
    else if (c <= 6d+73) then
        tmp = x * (y * z)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -24000.0) {
		tmp = c * (t * j);
	} else if (c <= 2.2e-296) {
		tmp = i * (b * a);
	} else if (c <= 6e+73) {
		tmp = x * (y * z);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -24000.0:
		tmp = c * (t * j)
	elif c <= 2.2e-296:
		tmp = i * (b * a)
	elif c <= 6e+73:
		tmp = x * (y * z)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -24000.0)
		tmp = Float64(c * Float64(t * j));
	elseif (c <= 2.2e-296)
		tmp = Float64(i * Float64(b * a));
	elseif (c <= 6e+73)
		tmp = Float64(x * Float64(y * z));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -24000.0)
		tmp = c * (t * j);
	elseif (c <= 2.2e-296)
		tmp = i * (b * a);
	elseif (c <= 6e+73)
		tmp = x * (y * z);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -24000.0], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.2e-296], N[(i * N[(b * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6e+73], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if c < -24000

   1. Initial program 59.7%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -24000 < c < 2.20000000000000012e-296

   1. Initial program 83.2%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 2.20000000000000012e-296 < c < 6.00000000000000021e73

   1. Initial program 78.1%

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

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 6.00000000000000021e73 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 4 regimes into one program.
4. Add Preprocessing

Alternative 32: 51.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{if}\;c \leq -8.5 \cdot 10^{+59}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 5.8 \cdot 10^{+73}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* c (- (* t j) (* z b)))))
   (if (<= c -8.5e+59) t_1 (if (<= c 5.8e+73) (* a (- (* i b) (* x t))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -8.5e+59) {
		tmp = t_1;
	} else if (c <= 5.8e+73) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = c * ((t * j) - (z * b))
    if (c <= (-8.5d+59)) then
        tmp = t_1
    else if (c <= 5.8d+73) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -8.5e+59) {
		tmp = t_1;
	} else if (c <= 5.8e+73) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((t * j) - (z * b))
	tmp = 0
	if c <= -8.5e+59:
		tmp = t_1
	elif c <= 5.8e+73:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b)))
	tmp = 0.0
	if (c <= -8.5e+59)
		tmp = t_1;
	elseif (c <= 5.8e+73)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = c * ((t * j) - (z * b));
	tmp = 0.0;
	if (c <= -8.5e+59)
		tmp = t_1;
	elseif (c <= 5.8e+73)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -8.5e+59], t$95$1, If[LessEqual[c, 5.8e+73], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if c < -8.4999999999999999e59 or 5.8000000000000005e73 < c

   1. Initial program 60.2%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.4999999999999999e59 < c < 5.8000000000000005e73

   1. Initial program 79.8%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 33: 43.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.5 \cdot 10^{-16}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;z \leq 1.1 \cdot 10^{+169}:\\ \;\;\;\;a \cdot \left(i \cdot b - x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= z -2.5e-16)
   (* b (- (* a i) (* z c)))
   (if (<= z 1.1e+169) (* a (- (* i b) (* x t))) (* y (* x z)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (z <= -2.5e-16) {
		tmp = b * ((a * i) - (z * c));
	} else if (z <= 1.1e+169) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = y * (x * z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (z <= (-2.5d-16)) then
        tmp = b * ((a * i) - (z * c))
    else if (z <= 1.1d+169) then
        tmp = a * ((i * b) - (x * t))
    else
        tmp = y * (x * z)
    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 tmp;
	if (z <= -2.5e-16) {
		tmp = b * ((a * i) - (z * c));
	} else if (z <= 1.1e+169) {
		tmp = a * ((i * b) - (x * t));
	} else {
		tmp = y * (x * z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if z <= -2.5e-16:
		tmp = b * ((a * i) - (z * c))
	elif z <= 1.1e+169:
		tmp = a * ((i * b) - (x * t))
	else:
		tmp = y * (x * z)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (z <= -2.5e-16)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (z <= 1.1e+169)
		tmp = Float64(a * Float64(Float64(i * b) - Float64(x * t)));
	else
		tmp = Float64(y * Float64(x * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (z <= -2.5e-16)
		tmp = b * ((a * i) - (z * c));
	elseif (z <= 1.1e+169)
		tmp = a * ((i * b) - (x * t));
	else
		tmp = y * (x * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.5e-16], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e+169], N[(a * N[(N[(i * b), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -2.5000000000000002e-16

   1. Initial program 69.7%

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

   3. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.5000000000000002e-16 < z < 1.1e169

   1. Initial program 76.5%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.1e169 < z

   1. Initial program 53.2%

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

   3. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 34: 29.4% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -15500:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;c \leq 5.5 \cdot 10^{+73}:\\ \;\;\;\;a \cdot \left(i \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= c -15500.0)
   (* c (* t j))
   (if (<= c 5.5e+73) (* a (* i b)) (* j (* c t)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -15500.0) {
		tmp = c * (t * j);
	} else if (c <= 5.5e+73) {
		tmp = a * (i * b);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: tmp
    if (c <= (-15500.0d0)) then
        tmp = c * (t * j)
    else if (c <= 5.5d+73) then
        tmp = a * (i * b)
    else
        tmp = j * (c * t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -15500.0) {
		tmp = c * (t * j);
	} else if (c <= 5.5e+73) {
		tmp = a * (i * b);
	} else {
		tmp = j * (c * t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -15500.0:
		tmp = c * (t * j)
	elif c <= 5.5e+73:
		tmp = a * (i * b)
	else:
		tmp = j * (c * t)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -15500.0)
		tmp = Float64(c * Float64(t * j));
	elseif (c <= 5.5e+73)
		tmp = Float64(a * Float64(i * b));
	else
		tmp = Float64(j * Float64(c * t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -15500.0)
		tmp = c * (t * j);
	elseif (c <= 5.5e+73)
		tmp = a * (i * b);
	else
		tmp = j * (c * t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -15500.0], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.5e+73], N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if c < -15500

   1. Initial program 59.7%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -15500 < c < 5.5000000000000003e73

   1. Initial program 80.7%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 5.5000000000000003e73 < c

   1. Initial program 63.8%

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

   3. Taylor expanded in y around 0 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 35: 29.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j\right)\\ \mathbf{if}\;c \leq -13500:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 9 \cdot 10^{+73}:\\ \;\;\;\;a \cdot \left(i \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* c (* t j))))
   (if (<= c -13500.0) t_1 (if (<= c 9e+73) (* a (* i b)) t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * (t * j);
	double tmp;
	if (c <= -13500.0) {
		tmp = t_1;
	} else if (c <= 9e+73) {
		tmp = a * (i * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: tmp
    t_1 = c * (t * j)
    if (c <= (-13500.0d0)) then
        tmp = t_1
    else if (c <= 9d+73) then
        tmp = a * (i * b)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * (t * j);
	double tmp;
	if (c <= -13500.0) {
		tmp = t_1;
	} else if (c <= 9e+73) {
		tmp = a * (i * b);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * (t * j)
	tmp = 0
	if c <= -13500.0:
		tmp = t_1
	elif c <= 9e+73:
		tmp = a * (i * b)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(t * j))
	tmp = 0.0
	if (c <= -13500.0)
		tmp = t_1;
	elseif (c <= 9e+73)
		tmp = Float64(a * Float64(i * b));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = c * (t * j);
	tmp = 0.0;
	if (c <= -13500.0)
		tmp = t_1;
	elseif (c <= 9e+73)
		tmp = a * (i * b);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -13500.0], t$95$1, If[LessEqual[c, 9e+73], N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if c < -13500 or 8.99999999999999969e73 < c

   1. Initial program 61.3%

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

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -13500 < c < 8.99999999999999969e73

   1. Initial program 80.7%

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

   3. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in i around inf 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 36: 22.2% accurate, 5.8× speedup

Math

\[\begin{array}{l} \\ a \cdot \left(i \cdot b\right) \end{array} \]

FPCore

(FPCore (x y z t a b c i j) :precision binary64 (* a (* i b)))

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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
    code = a * (i * b)
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) {
	return a * (i * b);
}

Python

def code(x, y, z, t, a, b, c, i, j):
	return a * (i * b)

Julia

function code(x, y, z, t, a, b, c, i, j)
	return Float64(a * Float64(i * b))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j)
	tmp = a * (i * b);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(i * b), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 72.3%

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

3. Taylor expanded in a around inf 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in i around inf 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Developer target: 67.8% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\ t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\ \mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1
         (+
          (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
          (/
           (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
           (+ (* c t) (* i y)))))
        (t_2
         (-
          (* x (- (* z y) (* a t)))
          (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
   (if (< t -8.120978919195912e-33)
     t_2
     (if (< t -4.712553818218485e-169)
       t_1
       (if (< t -7.633533346031584e-308)
         t_2
         (if (< t 1.0535888557455487e-139) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
	double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
	double tmp;
	if (t < -8.120978919195912e-33) {
		tmp = t_2;
	} else if (t < -4.712553818218485e-169) {
		tmp = t_1;
	} else if (t < -7.633533346031584e-308) {
		tmp = t_2;
	} else if (t < 1.0535888557455487e-139) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
    t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
    if (t < (-8.120978919195912d-33)) then
        tmp = t_2
    else if (t < (-4.712553818218485d-169)) then
        tmp = t_1
    else if (t < (-7.633533346031584d-308)) then
        tmp = t_2
    else if (t < 1.0535888557455487d-139) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
	double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
	double tmp;
	if (t < -8.120978919195912e-33) {
		tmp = t_2;
	} else if (t < -4.712553818218485e-169) {
		tmp = t_1;
	} else if (t < -7.633533346031584e-308) {
		tmp = t_2;
	} else if (t < 1.0535888557455487e-139) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y)))
	t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
	tmp = 0
	if t < -8.120978919195912e-33:
		tmp = t_2
	elif t < -4.712553818218485e-169:
		tmp = t_1
	elif t < -7.633533346031584e-308:
		tmp = t_2
	elif t < 1.0535888557455487e-139:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y))))
	t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j)))
	tmp = 0.0
	if (t < -8.120978919195912e-33)
		tmp = t_2;
	elseif (t < -4.712553818218485e-169)
		tmp = t_1;
	elseif (t < -7.633533346031584e-308)
		tmp = t_2;
	elseif (t < 1.0535888557455487e-139)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y)));
	t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
	tmp = 0.0;
	if (t < -8.120978919195912e-33)
		tmp = t_2;
	elseif (t < -4.712553818218485e-169)
		tmp = t_1;
	elseif (t < -7.633533346031584e-308)
		tmp = t_2;
	elseif (t < 1.0535888557455487e-139)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z t a b c i j)
  :name "Linear.Matrix:det33 from linear-1.19.1.3"
  :precision binary64

  :alt
  (if (< t -8.120978919195912e-33) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -4.712553818218485e-169) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (if (< t -7.633533346031584e-308) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 1.0535888557455487e-139) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))))

  (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))