Linear.Matrix:det33 from linear-1.19.1.3

Percentage Accurate: 73.9% → 82.6%

Time: 28.2s

Alternatives: 20

Speedup: 0.5×

• 59.3% 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: 73.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: 82.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right) - \left(x \cdot \left(t \cdot a - y \cdot z\right) - b \cdot \left(a \cdot i - z \cdot c\right)\right)\\ \mathbf{if}\;t_1 \leq \infty:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\ \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)))
          (- (* x (- (* t a) (* y z))) (* b (- (* a i) (* z c)))))))
   (if (<= t_1 INFINITY) t_1 (* z (- (* x y) (* b c))))))

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))) - ((x * ((t * a) - (y * z))) - (b * ((a * i) - (z * c))));
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = t_1;
	} else {
		tmp = z * ((x * y) - (b * c));
	}
	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 = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (b * ((a * i) - (z * c))));
	double tmp;
	if (t_1 <= Double.POSITIVE_INFINITY) {
		tmp = t_1;
	} else {
		tmp = z * ((x * y) - (b * c));
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(Float64(x * Float64(Float64(t * a) - Float64(y * z))) - Float64(b * Float64(Float64(a * i) - Float64(z * c)))))
	tmp = 0.0
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c)));
	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))) - ((x * ((t * a) - (y * z))) - (b * ((a * i) - (z * c))));
	tmp = 0.0;
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = z * ((x * y) - (b * c));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $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 91.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) \]

   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. Taylor expanded in z around inf 54.1%

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

      1. *-commutative 54.1%

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

      2. *-commutative 54.1%

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

   4. Simplified 54.1%

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

4. Final simplification 85.2%

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

Alternative 2: 70.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_3 := x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{if}\;b \leq -1.1 \cdot 10^{+71}:\\ \;\;\;\;t_3 + t_2\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-100}:\\ \;\;\;\;t_1 + t_3\\ \mathbf{elif}\;b \leq -3 \cdot 10^{-117}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 1.3 \cdot 10^{+51}:\\ \;\;\;\;t_1 - \left(z \cdot \left(b \cdot c\right) + x \cdot \left(t \cdot a - y \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_2 + z \cdot \left(x \cdot y\right)\\ \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))))
        (t_2 (* b (- (* a i) (* z c))))
        (t_3 (* x (- (* y z) (* t a)))))
   (if (<= b -1.1e+71)
     (+ t_3 t_2)
     (if (<= b -1.7e-100)
       (+ t_1 t_3)
       (if (<= b -3e-117)
         t_2
         (if (<= b 1.3e+51)
           (- t_1 (+ (* z (* b c)) (* x (- (* t a) (* y z)))))
           (+ t_2 (* z (* x y)))))))))

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 t_2 = b * ((a * i) - (z * c));
	double t_3 = x * ((y * z) - (t * a));
	double tmp;
	if (b <= -1.1e+71) {
		tmp = t_3 + t_2;
	} else if (b <= -1.7e-100) {
		tmp = t_1 + t_3;
	} else if (b <= -3e-117) {
		tmp = t_2;
	} else if (b <= 1.3e+51) {
		tmp = t_1 - ((z * (b * c)) + (x * ((t * a) - (y * z))));
	} else {
		tmp = t_2 + (z * (x * y));
	}
	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 = j * ((t * c) - (y * i))
    t_2 = b * ((a * i) - (z * c))
    t_3 = x * ((y * z) - (t * a))
    if (b <= (-1.1d+71)) then
        tmp = t_3 + t_2
    else if (b <= (-1.7d-100)) then
        tmp = t_1 + t_3
    else if (b <= (-3d-117)) then
        tmp = t_2
    else if (b <= 1.3d+51) then
        tmp = t_1 - ((z * (b * c)) + (x * ((t * a) - (y * z))))
    else
        tmp = t_2 + (z * (x * y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double t_2 = b * ((a * i) - (z * c));
	double t_3 = x * ((y * z) - (t * a));
	double tmp;
	if (b <= -1.1e+71) {
		tmp = t_3 + t_2;
	} else if (b <= -1.7e-100) {
		tmp = t_1 + t_3;
	} else if (b <= -3e-117) {
		tmp = t_2;
	} else if (b <= 1.3e+51) {
		tmp = t_1 - ((z * (b * c)) + (x * ((t * a) - (y * z))));
	} else {
		tmp = t_2 + (z * (x * y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	t_2 = b * ((a * i) - (z * c))
	t_3 = x * ((y * z) - (t * a))
	tmp = 0
	if b <= -1.1e+71:
		tmp = t_3 + t_2
	elif b <= -1.7e-100:
		tmp = t_1 + t_3
	elif b <= -3e-117:
		tmp = t_2
	elif b <= 1.3e+51:
		tmp = t_1 - ((z * (b * c)) + (x * ((t * a) - (y * z))))
	else:
		tmp = t_2 + (z * (x * y))
	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)))
	t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	t_3 = Float64(x * Float64(Float64(y * z) - Float64(t * a)))
	tmp = 0.0
	if (b <= -1.1e+71)
		tmp = Float64(t_3 + t_2);
	elseif (b <= -1.7e-100)
		tmp = Float64(t_1 + t_3);
	elseif (b <= -3e-117)
		tmp = t_2;
	elseif (b <= 1.3e+51)
		tmp = Float64(t_1 - Float64(Float64(z * Float64(b * c)) + Float64(x * Float64(Float64(t * a) - Float64(y * z)))));
	else
		tmp = Float64(t_2 + Float64(z * Float64(x * y)));
	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));
	t_2 = b * ((a * i) - (z * c));
	t_3 = x * ((y * z) - (t * a));
	tmp = 0.0;
	if (b <= -1.1e+71)
		tmp = t_3 + t_2;
	elseif (b <= -1.7e-100)
		tmp = t_1 + t_3;
	elseif (b <= -3e-117)
		tmp = t_2;
	elseif (b <= 1.3e+51)
		tmp = t_1 - ((z * (b * c)) + (x * ((t * a) - (y * z))));
	else
		tmp = t_2 + (z * (x * y));
	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]}, 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[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.1e+71], N[(t$95$3 + t$95$2), $MachinePrecision], If[LessEqual[b, -1.7e-100], N[(t$95$1 + t$95$3), $MachinePrecision], If[LessEqual[b, -3e-117], t$95$2, If[LessEqual[b, 1.3e+51], N[(t$95$1 - N[(N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$2 + N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if b < -1.09999999999999997e71

   1. Initial program 81.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. Taylor expanded in j around 0 86.1%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 86.1%

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

      2. *-commutative 86.1%

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

      3. cancel-sign-sub-inv 86.1%

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

      4. *-commutative 86.1%

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

   4. Simplified 86.1%

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

   if -1.09999999999999997e71 < b < -1.69999999999999988e-100

   1. Initial program 71.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. Taylor expanded in b around 0 77.3%

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

   if -1.69999999999999988e-100 < b < -2.99999999999999991e-117

   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. Taylor expanded in b around inf 80.4%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 80.4%

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

   4. Simplified 80.4%

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

   if -2.99999999999999991e-117 < b < 1.3000000000000001e51

   1. Initial program 79.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. Taylor expanded in c around inf 75.1%

      \[\leadsto \left(x \cdot \left(y \cdot z - t \cdot a\right) - \color{blue}{b \cdot \left(c \cdot z\right)}\right) + j \cdot \left(c \cdot t - i \cdot y\right) \]
   3. Step-by-step derivation

      1. *-commutative 75.1%

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

      2. *-commutative 75.1%

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

      3. associate-*l* 77.7%

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

   4. Simplified 77.7%

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

   if 1.3000000000000001e51 < b

   1. Initial program 70.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. Taylor expanded in j around 0 77.3%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 77.3%

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

      2. *-commutative 77.3%

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

      3. cancel-sign-sub-inv 77.3%

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

      4. *-commutative 77.3%

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

   4. Simplified 77.3%

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

   5. Taylor expanded in y around inf 77.4%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z\right)} - b \cdot \left(c \cdot z - i \cdot a\right) \]
   6. Step-by-step derivation

      1. associate-*r* 80.6%

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

      2. *-commutative 80.6%

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

   7. Simplified 80.6%

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

4. Final simplification 79.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.1 \cdot 10^{+71}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-100}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq -3 \cdot 10^{-117}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq 1.3 \cdot 10^{+51}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - \left(z \cdot \left(b \cdot c\right) + x \cdot \left(t \cdot a - y \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 3: 68.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := t_1 + z \cdot \left(x \cdot y\right)\\ t_3 := j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{if}\;b \leq -3.8 \cdot 10^{+85}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-100}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -3 \cdot 10^{-117}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+51}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \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_1 (* z (* x y))))
        (t_3 (+ (* j (- (* t c) (* y i))) (* x (- (* y z) (* t a))))))
   (if (<= b -3.8e+85)
     t_2
     (if (<= b -1.7e-100)
       t_3
       (if (<= b -3e-117) t_1 (if (<= b 4.8e+51) t_3 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 = b * ((a * i) - (z * c));
	double t_2 = t_1 + (z * (x * y));
	double t_3 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	double tmp;
	if (b <= -3.8e+85) {
		tmp = t_2;
	} else if (b <= -1.7e-100) {
		tmp = t_3;
	} else if (b <= -3e-117) {
		tmp = t_1;
	} else if (b <= 4.8e+51) {
		tmp = t_3;
	} 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) :: t_3
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    t_2 = t_1 + (z * (x * y))
    t_3 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
    if (b <= (-3.8d+85)) then
        tmp = t_2
    else if (b <= (-1.7d-100)) then
        tmp = t_3
    else if (b <= (-3d-117)) then
        tmp = t_1
    else if (b <= 4.8d+51) then
        tmp = t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = t_1 + (z * (x * y));
	double t_3 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	double tmp;
	if (b <= -3.8e+85) {
		tmp = t_2;
	} else if (b <= -1.7e-100) {
		tmp = t_3;
	} else if (b <= -3e-117) {
		tmp = t_1;
	} else if (b <= 4.8e+51) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	t_2 = t_1 + (z * (x * y))
	t_3 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
	tmp = 0
	if b <= -3.8e+85:
		tmp = t_2
	elif b <= -1.7e-100:
		tmp = t_3
	elif b <= -3e-117:
		tmp = t_1
	elif b <= 4.8e+51:
		tmp = t_3
	else:
		tmp = t_2
	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_1 + Float64(z * Float64(x * y)))
	t_3 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(x * Float64(Float64(y * z) - Float64(t * a))))
	tmp = 0.0
	if (b <= -3.8e+85)
		tmp = t_2;
	elseif (b <= -1.7e-100)
		tmp = t_3;
	elseif (b <= -3e-117)
		tmp = t_1;
	elseif (b <= 4.8e+51)
		tmp = t_3;
	else
		tmp = t_2;
	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_1 + (z * (x * y));
	t_3 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	tmp = 0.0;
	if (b <= -3.8e+85)
		tmp = t_2;
	elseif (b <= -1.7e-100)
		tmp = t_3;
	elseif (b <= -3e-117)
		tmp = t_1;
	elseif (b <= 4.8e+51)
		tmp = t_3;
	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[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.8e+85], t$95$2, If[LessEqual[b, -1.7e-100], t$95$3, If[LessEqual[b, -3e-117], t$95$1, If[LessEqual[b, 4.8e+51], t$95$3, t$95$2]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -3.79999999999999992e85 or 4.7999999999999997e51 < b

   1. Initial program 74.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. Taylor expanded in j around 0 80.6%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 80.6%

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

      2. *-commutative 80.6%

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

      3. cancel-sign-sub-inv 80.6%

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

      4. *-commutative 80.6%

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

   4. Simplified 80.6%

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

   5. Taylor expanded in y around inf 76.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z\right)} - b \cdot \left(c \cdot z - i \cdot a\right) \]
   6. Step-by-step derivation

      1. associate-*r* 79.7%

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

      2. *-commutative 79.7%

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

   7. Simplified 79.7%

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

   if -3.79999999999999992e85 < b < -1.69999999999999988e-100 or -2.99999999999999991e-117 < b < 4.7999999999999997e51

   1. Initial program 77.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. Taylor expanded in b around 0 75.5%

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

   if -1.69999999999999988e-100 < b < -2.99999999999999991e-117

   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. Taylor expanded in b around inf 80.4%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 80.4%

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

   4. Simplified 80.4%

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

4. Final simplification 77.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -3.8 \cdot 10^{+85}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;b \leq -1.7 \cdot 10^{-100}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq -3 \cdot 10^{-117}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+51}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 4: 67.9% accurate, 1.1× 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 - t \cdot a\right)\\ t_3 := j \cdot \left(t \cdot c - y \cdot i\right) + t_2\\ t_4 := t_2 + t_1\\ \mathbf{if}\;b \leq -2.5 \cdot 10^{+71}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq -2.7 \cdot 10^{-70}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;b \leq -2.4 \cdot 10^{-153}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;b \leq 4 \cdot 10^{+49}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_1 + z \cdot \left(x \cdot y\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 (* x (- (* y z) (* t a))))
        (t_3 (+ (* j (- (* t c) (* y i))) t_2))
        (t_4 (+ t_2 t_1)))
   (if (<= b -2.5e+71)
     t_4
     (if (<= b -2.7e-70)
       t_3
       (if (<= b -2.4e-153)
         t_4
         (if (<= b 4e+49) t_3 (+ t_1 (* z (* x y)))))))))

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) - (t * a));
	double t_3 = (j * ((t * c) - (y * i))) + t_2;
	double t_4 = t_2 + t_1;
	double tmp;
	if (b <= -2.5e+71) {
		tmp = t_4;
	} else if (b <= -2.7e-70) {
		tmp = t_3;
	} else if (b <= -2.4e-153) {
		tmp = t_4;
	} else if (b <= 4e+49) {
		tmp = t_3;
	} else {
		tmp = t_1 + (z * (x * y));
	}
	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 = x * ((y * z) - (t * a))
    t_3 = (j * ((t * c) - (y * i))) + t_2
    t_4 = t_2 + t_1
    if (b <= (-2.5d+71)) then
        tmp = t_4
    else if (b <= (-2.7d-70)) then
        tmp = t_3
    else if (b <= (-2.4d-153)) then
        tmp = t_4
    else if (b <= 4d+49) then
        tmp = t_3
    else
        tmp = t_1 + (z * (x * y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double t_2 = x * ((y * z) - (t * a));
	double t_3 = (j * ((t * c) - (y * i))) + t_2;
	double t_4 = t_2 + t_1;
	double tmp;
	if (b <= -2.5e+71) {
		tmp = t_4;
	} else if (b <= -2.7e-70) {
		tmp = t_3;
	} else if (b <= -2.4e-153) {
		tmp = t_4;
	} else if (b <= 4e+49) {
		tmp = t_3;
	} else {
		tmp = t_1 + (z * (x * y));
	}
	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) - (t * a))
	t_3 = (j * ((t * c) - (y * i))) + t_2
	t_4 = t_2 + t_1
	tmp = 0
	if b <= -2.5e+71:
		tmp = t_4
	elif b <= -2.7e-70:
		tmp = t_3
	elif b <= -2.4e-153:
		tmp = t_4
	elif b <= 4e+49:
		tmp = t_3
	else:
		tmp = t_1 + (z * (x * y))
	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(t * a)))
	t_3 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + t_2)
	t_4 = Float64(t_2 + t_1)
	tmp = 0.0
	if (b <= -2.5e+71)
		tmp = t_4;
	elseif (b <= -2.7e-70)
		tmp = t_3;
	elseif (b <= -2.4e-153)
		tmp = t_4;
	elseif (b <= 4e+49)
		tmp = t_3;
	else
		tmp = Float64(t_1 + Float64(z * Float64(x * y)));
	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) - (t * a));
	t_3 = (j * ((t * c) - (y * i))) + t_2;
	t_4 = t_2 + t_1;
	tmp = 0.0;
	if (b <= -2.5e+71)
		tmp = t_4;
	elseif (b <= -2.7e-70)
		tmp = t_3;
	elseif (b <= -2.4e-153)
		tmp = t_4;
	elseif (b <= 4e+49)
		tmp = t_3;
	else
		tmp = t_1 + (z * (x * y));
	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[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 + t$95$1), $MachinePrecision]}, If[LessEqual[b, -2.5e+71], t$95$4, If[LessEqual[b, -2.7e-70], t$95$3, If[LessEqual[b, -2.4e-153], t$95$4, If[LessEqual[b, 4e+49], t$95$3, N[(t$95$1 + N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -2.49999999999999986e71 or -2.7000000000000001e-70 < b < -2.4000000000000002e-153

   1. Initial program 80.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. Taylor expanded in j around 0 84.0%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 84.0%

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

      2. *-commutative 84.0%

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

      3. cancel-sign-sub-inv 84.0%

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

      4. *-commutative 84.0%

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

   4. Simplified 84.0%

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

   if -2.49999999999999986e71 < b < -2.7000000000000001e-70 or -2.4000000000000002e-153 < b < 3.99999999999999979e49

   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. Taylor expanded in b around 0 76.2%

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

   if 3.99999999999999979e49 < b

   1. Initial program 70.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. Taylor expanded in j around 0 77.3%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 77.3%

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

      2. *-commutative 77.3%

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

      3. cancel-sign-sub-inv 77.3%

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

      4. *-commutative 77.3%

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

   4. Simplified 77.3%

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

   5. Taylor expanded in y around inf 77.4%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z\right)} - b \cdot \left(c \cdot z - i \cdot a\right) \]
   6. Step-by-step derivation

      1. associate-*r* 80.6%

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

      2. *-commutative 80.6%

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

   7. Simplified 80.6%

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

4. Final simplification 79.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2.5 \cdot 10^{+71}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq -2.7 \cdot 10^{-70}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq -2.4 \cdot 10^{-153}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq 4 \cdot 10^{+49}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 5: 30.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\ t_2 := \left(z \cdot c\right) \cdot \left(-b\right)\\ \mathbf{if}\;x \leq -5.2 \cdot 10^{+159}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -4 \cdot 10^{+45}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq -0.047:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -2.65 \cdot 10^{-95}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -6.6 \cdot 10^{-205}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;x \leq 2.7 \cdot 10^{-285}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq 5.2 \cdot 10^{+62}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;x \leq 2.7 \cdot 10^{+220}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* (- a) (* x t))) (t_2 (* (* z c) (- b))))
   (if (<= x -5.2e+159)
     t_1
     (if (<= x -4e+45)
       (* x (* y z))
       (if (<= x -0.047)
         t_1
         (if (<= x -2.65e-95)
           t_2
           (if (<= x -6.6e-205)
             (* b (* a i))
             (if (<= x 2.7e-285)
               t_2
               (if (<= x 5.2e+62)
                 (* a (* b i))
                 (if (<= x 2.7e+220) t_1 (* z (* x y))))))))))))

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 * (x * t);
	double t_2 = (z * c) * -b;
	double tmp;
	if (x <= -5.2e+159) {
		tmp = t_1;
	} else if (x <= -4e+45) {
		tmp = x * (y * z);
	} else if (x <= -0.047) {
		tmp = t_1;
	} else if (x <= -2.65e-95) {
		tmp = t_2;
	} else if (x <= -6.6e-205) {
		tmp = b * (a * i);
	} else if (x <= 2.7e-285) {
		tmp = t_2;
	} else if (x <= 5.2e+62) {
		tmp = a * (b * i);
	} else if (x <= 2.7e+220) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	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 * (x * t)
    t_2 = (z * c) * -b
    if (x <= (-5.2d+159)) then
        tmp = t_1
    else if (x <= (-4d+45)) then
        tmp = x * (y * z)
    else if (x <= (-0.047d0)) then
        tmp = t_1
    else if (x <= (-2.65d-95)) then
        tmp = t_2
    else if (x <= (-6.6d-205)) then
        tmp = b * (a * i)
    else if (x <= 2.7d-285) then
        tmp = t_2
    else if (x <= 5.2d+62) then
        tmp = a * (b * i)
    else if (x <= 2.7d+220) then
        tmp = t_1
    else
        tmp = z * (x * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = -a * (x * t);
	double t_2 = (z * c) * -b;
	double tmp;
	if (x <= -5.2e+159) {
		tmp = t_1;
	} else if (x <= -4e+45) {
		tmp = x * (y * z);
	} else if (x <= -0.047) {
		tmp = t_1;
	} else if (x <= -2.65e-95) {
		tmp = t_2;
	} else if (x <= -6.6e-205) {
		tmp = b * (a * i);
	} else if (x <= 2.7e-285) {
		tmp = t_2;
	} else if (x <= 5.2e+62) {
		tmp = a * (b * i);
	} else if (x <= 2.7e+220) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = -a * (x * t)
	t_2 = (z * c) * -b
	tmp = 0
	if x <= -5.2e+159:
		tmp = t_1
	elif x <= -4e+45:
		tmp = x * (y * z)
	elif x <= -0.047:
		tmp = t_1
	elif x <= -2.65e-95:
		tmp = t_2
	elif x <= -6.6e-205:
		tmp = b * (a * i)
	elif x <= 2.7e-285:
		tmp = t_2
	elif x <= 5.2e+62:
		tmp = a * (b * i)
	elif x <= 2.7e+220:
		tmp = t_1
	else:
		tmp = z * (x * y)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(-a) * Float64(x * t))
	t_2 = Float64(Float64(z * c) * Float64(-b))
	tmp = 0.0
	if (x <= -5.2e+159)
		tmp = t_1;
	elseif (x <= -4e+45)
		tmp = Float64(x * Float64(y * z));
	elseif (x <= -0.047)
		tmp = t_1;
	elseif (x <= -2.65e-95)
		tmp = t_2;
	elseif (x <= -6.6e-205)
		tmp = Float64(b * Float64(a * i));
	elseif (x <= 2.7e-285)
		tmp = t_2;
	elseif (x <= 5.2e+62)
		tmp = Float64(a * Float64(b * i));
	elseif (x <= 2.7e+220)
		tmp = t_1;
	else
		tmp = Float64(z * Float64(x * y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = -a * (x * t);
	t_2 = (z * c) * -b;
	tmp = 0.0;
	if (x <= -5.2e+159)
		tmp = t_1;
	elseif (x <= -4e+45)
		tmp = x * (y * z);
	elseif (x <= -0.047)
		tmp = t_1;
	elseif (x <= -2.65e-95)
		tmp = t_2;
	elseif (x <= -6.6e-205)
		tmp = b * (a * i);
	elseif (x <= 2.7e-285)
		tmp = t_2;
	elseif (x <= 5.2e+62)
		tmp = a * (b * i);
	elseif (x <= 2.7e+220)
		tmp = t_1;
	else
		tmp = z * (x * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z * c), $MachinePrecision] * (-b)), $MachinePrecision]}, If[LessEqual[x, -5.2e+159], t$95$1, If[LessEqual[x, -4e+45], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -0.047], t$95$1, If[LessEqual[x, -2.65e-95], t$95$2, If[LessEqual[x, -6.6e-205], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7e-285], t$95$2, If[LessEqual[x, 5.2e+62], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7e+220], t$95$1, N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if x < -5.2000000000000001e159 or -3.9999999999999997e45 < x < -0.047 or 5.19999999999999968e62 < x < 2.6999999999999998e220

   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. Taylor expanded in j around 0 71.3%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 71.3%

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

      2. *-commutative 71.3%

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

      3. cancel-sign-sub-inv 71.3%

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

      4. *-commutative 71.3%

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

   4. Simplified 71.3%

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

   5. Taylor expanded in t around inf 52.8%

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

      1. mul-1-neg 52.8%

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

      2. distribute-rgt-neg-in 52.8%

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

      3. distribute-rgt-neg-in 52.8%

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

   7. Simplified 52.8%

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

   if -5.2000000000000001e159 < x < -3.9999999999999997e45

   1. Initial program 76.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. Taylor expanded in j around 0 69.6%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 69.6%

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

      2. *-commutative 69.6%

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

      3. cancel-sign-sub-inv 69.6%

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

      4. *-commutative 69.6%

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

   4. Simplified 69.6%

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

   5. Taylor expanded in y around inf 53.2%

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

      1. *-commutative 53.2%

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

   7. Simplified 53.2%

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

   if -0.047 < x < -2.6499999999999999e-95 or -6.5999999999999998e-205 < x < 2.6999999999999998e-285

   1. Initial program 71.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. Taylor expanded in b around inf 57.3%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 57.3%

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

   4. Simplified 57.3%

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

   5. Taylor expanded in i around 0 43.6%

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

      1. mul-1-neg 43.6%

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

      2. distribute-lft-neg-out 43.6%

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

      3. *-commutative 43.6%

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

   7. Simplified 43.6%

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

   if -2.6499999999999999e-95 < x < -6.5999999999999998e-205

   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. Taylor expanded in b around inf 41.9%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 41.9%

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

   4. Simplified 41.9%

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

   5. Taylor expanded in i around inf 36.7%

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

   if 2.6999999999999998e-285 < x < 5.19999999999999968e62

   1. Initial program 75.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. Taylor expanded in j around 0 66.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 66.8%

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

      2. *-commutative 66.8%

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

      3. cancel-sign-sub-inv 66.8%

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

      4. *-commutative 66.8%

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

   4. Simplified 66.8%

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

   5. Taylor expanded in i around inf 44.0%

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

   if 2.6999999999999998e220 < x

   1. Initial program 86.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. Taylor expanded in j around 0 82.7%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 82.7%

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

      2. *-commutative 82.7%

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

      3. cancel-sign-sub-inv 82.7%

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

      4. *-commutative 82.7%

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

   4. Simplified 82.7%

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

   5. Taylor expanded in y around inf 49.3%

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

      1. associate-*r* 53.5%

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

      2. *-commutative 53.5%

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

   7. Simplified 53.5%

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

4. Final simplification 47.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -5.2 \cdot 10^{+159}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq -4 \cdot 10^{+45}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq -0.047:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq -2.65 \cdot 10^{-95}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right)\\ \mathbf{elif}\;x \leq -6.6 \cdot 10^{-205}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;x \leq 2.7 \cdot 10^{-285}:\\ \;\;\;\;\left(z \cdot c\right) \cdot \left(-b\right)\\ \mathbf{elif}\;x \leq 5.2 \cdot 10^{+62}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;x \leq 2.7 \cdot 10^{+220}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 6: 30.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\ t_2 := z \cdot \left(b \cdot \left(-c\right)\right)\\ \mathbf{if}\;x \leq -1.12 \cdot 10^{+161}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -5 \cdot 10^{+50}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq -0.15:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -8.5 \cdot 10^{-75}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -5 \cdot 10^{-177}:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-275}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq 5 \cdot 10^{+63}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;x \leq 2.4 \cdot 10^{+220}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* (- a) (* x t))) (t_2 (* z (* b (- c)))))
   (if (<= x -1.12e+161)
     t_1
     (if (<= x -5e+50)
       (* x (* y z))
       (if (<= x -0.15)
         t_1
         (if (<= x -8.5e-75)
           t_2
           (if (<= x -5e-177)
             (* c (* t j))
             (if (<= x 1.5e-275)
               t_2
               (if (<= x 5e+63)
                 (* a (* b i))
                 (if (<= x 2.4e+220) t_1 (* z (* x y))))))))))))

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 * (x * t);
	double t_2 = z * (b * -c);
	double tmp;
	if (x <= -1.12e+161) {
		tmp = t_1;
	} else if (x <= -5e+50) {
		tmp = x * (y * z);
	} else if (x <= -0.15) {
		tmp = t_1;
	} else if (x <= -8.5e-75) {
		tmp = t_2;
	} else if (x <= -5e-177) {
		tmp = c * (t * j);
	} else if (x <= 1.5e-275) {
		tmp = t_2;
	} else if (x <= 5e+63) {
		tmp = a * (b * i);
	} else if (x <= 2.4e+220) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	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 * (x * t)
    t_2 = z * (b * -c)
    if (x <= (-1.12d+161)) then
        tmp = t_1
    else if (x <= (-5d+50)) then
        tmp = x * (y * z)
    else if (x <= (-0.15d0)) then
        tmp = t_1
    else if (x <= (-8.5d-75)) then
        tmp = t_2
    else if (x <= (-5d-177)) then
        tmp = c * (t * j)
    else if (x <= 1.5d-275) then
        tmp = t_2
    else if (x <= 5d+63) then
        tmp = a * (b * i)
    else if (x <= 2.4d+220) then
        tmp = t_1
    else
        tmp = z * (x * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = -a * (x * t);
	double t_2 = z * (b * -c);
	double tmp;
	if (x <= -1.12e+161) {
		tmp = t_1;
	} else if (x <= -5e+50) {
		tmp = x * (y * z);
	} else if (x <= -0.15) {
		tmp = t_1;
	} else if (x <= -8.5e-75) {
		tmp = t_2;
	} else if (x <= -5e-177) {
		tmp = c * (t * j);
	} else if (x <= 1.5e-275) {
		tmp = t_2;
	} else if (x <= 5e+63) {
		tmp = a * (b * i);
	} else if (x <= 2.4e+220) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = -a * (x * t)
	t_2 = z * (b * -c)
	tmp = 0
	if x <= -1.12e+161:
		tmp = t_1
	elif x <= -5e+50:
		tmp = x * (y * z)
	elif x <= -0.15:
		tmp = t_1
	elif x <= -8.5e-75:
		tmp = t_2
	elif x <= -5e-177:
		tmp = c * (t * j)
	elif x <= 1.5e-275:
		tmp = t_2
	elif x <= 5e+63:
		tmp = a * (b * i)
	elif x <= 2.4e+220:
		tmp = t_1
	else:
		tmp = z * (x * y)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(-a) * Float64(x * t))
	t_2 = Float64(z * Float64(b * Float64(-c)))
	tmp = 0.0
	if (x <= -1.12e+161)
		tmp = t_1;
	elseif (x <= -5e+50)
		tmp = Float64(x * Float64(y * z));
	elseif (x <= -0.15)
		tmp = t_1;
	elseif (x <= -8.5e-75)
		tmp = t_2;
	elseif (x <= -5e-177)
		tmp = Float64(c * Float64(t * j));
	elseif (x <= 1.5e-275)
		tmp = t_2;
	elseif (x <= 5e+63)
		tmp = Float64(a * Float64(b * i));
	elseif (x <= 2.4e+220)
		tmp = t_1;
	else
		tmp = Float64(z * Float64(x * y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = -a * (x * t);
	t_2 = z * (b * -c);
	tmp = 0.0;
	if (x <= -1.12e+161)
		tmp = t_1;
	elseif (x <= -5e+50)
		tmp = x * (y * z);
	elseif (x <= -0.15)
		tmp = t_1;
	elseif (x <= -8.5e-75)
		tmp = t_2;
	elseif (x <= -5e-177)
		tmp = c * (t * j);
	elseif (x <= 1.5e-275)
		tmp = t_2;
	elseif (x <= 5e+63)
		tmp = a * (b * i);
	elseif (x <= 2.4e+220)
		tmp = t_1;
	else
		tmp = z * (x * y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(b * (-c)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.12e+161], t$95$1, If[LessEqual[x, -5e+50], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -0.15], t$95$1, If[LessEqual[x, -8.5e-75], t$95$2, If[LessEqual[x, -5e-177], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.5e-275], t$95$2, If[LessEqual[x, 5e+63], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.4e+220], t$95$1, N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]

Derivation

1. Split input into 6 regimes

2. if x < -1.12e161 or -5e50 < x < -0.149999999999999994 or 5.00000000000000011e63 < x < 2.3999999999999998e220

   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. Taylor expanded in j around 0 71.3%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 71.3%

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

      2. *-commutative 71.3%

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

      3. cancel-sign-sub-inv 71.3%

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

      4. *-commutative 71.3%

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

   4. Simplified 71.3%

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

   5. Taylor expanded in t around inf 52.8%

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

      1. mul-1-neg 52.8%

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

      2. distribute-rgt-neg-in 52.8%

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

      3. distribute-rgt-neg-in 52.8%

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

   7. Simplified 52.8%

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

   if -1.12e161 < x < -5e50

   1. Initial program 76.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. Taylor expanded in j around 0 69.6%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 69.6%

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

      2. *-commutative 69.6%

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

      3. cancel-sign-sub-inv 69.6%

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

      4. *-commutative 69.6%

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

   4. Simplified 69.6%

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

   5. Taylor expanded in y around inf 53.2%

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

      1. *-commutative 53.2%

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

   7. Simplified 53.2%

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

   if -0.149999999999999994 < x < -8.5000000000000001e-75 or -5e-177 < x < 1.5e-275

   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. Taylor expanded in z around inf 57.2%

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

      1. *-commutative 57.2%

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

      2. *-commutative 57.2%

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

   4. Simplified 57.2%

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

   5. Taylor expanded in y around 0 45.3%

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

      1. neg-mul-1 45.3%

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

      2. distribute-rgt-neg-in 45.3%

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

   7. Simplified 45.3%

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

   if -8.5000000000000001e-75 < x < -5e-177

   1. Initial program 76.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. Taylor expanded in t around -inf 42.1%

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

      1. mul-1-neg 42.1%

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

      2. *-commutative 42.1%

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

      3. distribute-rgt-neg-in 42.1%

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

      4. +-commutative 42.1%

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

      5. mul-1-neg 42.1%

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

      6. unsub-neg 42.1%

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

      7. *-commutative 42.1%

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

      8. *-commutative 42.1%

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

   4. Simplified 42.1%

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

   5. Taylor expanded in x around 0 37.1%

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

      1. *-commutative 37.1%

         \[\leadsto c \cdot \color{blue}{\left(t \cdot j\right)} \]

   7. Simplified 37.1%

      \[\leadsto \color{blue}{c \cdot \left(t \cdot j\right)} \]

   if 1.5e-275 < x < 5.00000000000000011e63

   1. Initial program 75.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. Taylor expanded in j around 0 66.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 66.8%

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

      2. *-commutative 66.8%

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

      3. cancel-sign-sub-inv 66.8%

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

      4. *-commutative 66.8%

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

   4. Simplified 66.8%

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

   5. Taylor expanded in i around inf 44.0%

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

   if 2.3999999999999998e220 < x

   1. Initial program 86.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. Taylor expanded in j around 0 82.7%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 82.7%

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

      2. *-commutative 82.7%

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

      3. cancel-sign-sub-inv 82.7%

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

      4. *-commutative 82.7%

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

   4. Simplified 82.7%

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

   5. Taylor expanded in y around inf 49.3%

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

      1. associate-*r* 53.5%

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

      2. *-commutative 53.5%

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

   7. Simplified 53.5%

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

4. Final simplification 47.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.12 \cdot 10^{+161}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq -5 \cdot 10^{+50}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq -0.15:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq -8.5 \cdot 10^{-75}:\\ \;\;\;\;z \cdot \left(b \cdot \left(-c\right)\right)\\ \mathbf{elif}\;x \leq -5 \cdot 10^{-177}:\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-275}:\\ \;\;\;\;z \cdot \left(b \cdot \left(-c\right)\right)\\ \mathbf{elif}\;x \leq 5 \cdot 10^{+63}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;x \leq 2.4 \cdot 10^{+220}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 7: 41.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\ t_2 := \left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{if}\;x \leq -2.15 \cdot 10^{+161}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq -1.55 \cdot 10^{+90}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq 1.65 \cdot 10^{-302}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 1.45 \cdot 10^{+64}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;x \leq 2 \cdot 10^{+170}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;x \leq 2.25 \cdot 10^{+234}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \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 (* (- a) (* x t))))
   (if (<= x -2.15e+161)
     t_2
     (if (<= x -1.55e+90)
       (* x (* y z))
       (if (<= x 1.65e-302)
         t_1
         (if (<= x 1.45e+64)
           (* b (- (* a i) (* z c)))
           (if (<= x 2e+170) t_2 (if (<= x 2.25e+234) t_1 (* z (* x y))))))))))

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 = -a * (x * t);
	double tmp;
	if (x <= -2.15e+161) {
		tmp = t_2;
	} else if (x <= -1.55e+90) {
		tmp = x * (y * z);
	} else if (x <= 1.65e-302) {
		tmp = t_1;
	} else if (x <= 1.45e+64) {
		tmp = b * ((a * i) - (z * c));
	} else if (x <= 2e+170) {
		tmp = t_2;
	} else if (x <= 2.25e+234) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	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))
    t_2 = -a * (x * t)
    if (x <= (-2.15d+161)) then
        tmp = t_2
    else if (x <= (-1.55d+90)) then
        tmp = x * (y * z)
    else if (x <= 1.65d-302) then
        tmp = t_1
    else if (x <= 1.45d+64) then
        tmp = b * ((a * i) - (z * c))
    else if (x <= 2d+170) then
        tmp = t_2
    else if (x <= 2.25d+234) then
        tmp = t_1
    else
        tmp = z * (x * y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = c * ((t * j) - (z * b));
	double t_2 = -a * (x * t);
	double tmp;
	if (x <= -2.15e+161) {
		tmp = t_2;
	} else if (x <= -1.55e+90) {
		tmp = x * (y * z);
	} else if (x <= 1.65e-302) {
		tmp = t_1;
	} else if (x <= 1.45e+64) {
		tmp = b * ((a * i) - (z * c));
	} else if (x <= 2e+170) {
		tmp = t_2;
	} else if (x <= 2.25e+234) {
		tmp = t_1;
	} else {
		tmp = z * (x * y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((t * j) - (z * b))
	t_2 = -a * (x * t)
	tmp = 0
	if x <= -2.15e+161:
		tmp = t_2
	elif x <= -1.55e+90:
		tmp = x * (y * z)
	elif x <= 1.65e-302:
		tmp = t_1
	elif x <= 1.45e+64:
		tmp = b * ((a * i) - (z * c))
	elif x <= 2e+170:
		tmp = t_2
	elif x <= 2.25e+234:
		tmp = t_1
	else:
		tmp = z * (x * y)
	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(Float64(-a) * Float64(x * t))
	tmp = 0.0
	if (x <= -2.15e+161)
		tmp = t_2;
	elseif (x <= -1.55e+90)
		tmp = Float64(x * Float64(y * z));
	elseif (x <= 1.65e-302)
		tmp = t_1;
	elseif (x <= 1.45e+64)
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	elseif (x <= 2e+170)
		tmp = t_2;
	elseif (x <= 2.25e+234)
		tmp = t_1;
	else
		tmp = Float64(z * Float64(x * y));
	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 = -a * (x * t);
	tmp = 0.0;
	if (x <= -2.15e+161)
		tmp = t_2;
	elseif (x <= -1.55e+90)
		tmp = x * (y * z);
	elseif (x <= 1.65e-302)
		tmp = t_1;
	elseif (x <= 1.45e+64)
		tmp = b * ((a * i) - (z * c));
	elseif (x <= 2e+170)
		tmp = t_2;
	elseif (x <= 2.25e+234)
		tmp = t_1;
	else
		tmp = z * (x * y);
	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[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.15e+161], t$95$2, If[LessEqual[x, -1.55e+90], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.65e-302], t$95$1, If[LessEqual[x, 1.45e+64], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2e+170], t$95$2, If[LessEqual[x, 2.25e+234], t$95$1, N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if x < -2.15e161 or 1.44999999999999997e64 < x < 2.00000000000000007e170

   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. Taylor expanded in j around 0 70.6%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 70.6%

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

      2. *-commutative 70.6%

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

      3. cancel-sign-sub-inv 70.6%

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

      4. *-commutative 70.6%

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

   4. Simplified 70.6%

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

   5. Taylor expanded in t around inf 52.5%

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

      1. mul-1-neg 52.5%

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

      2. distribute-rgt-neg-in 52.5%

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

      3. distribute-rgt-neg-in 52.5%

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

   7. Simplified 52.5%

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

   if -2.15e161 < x < -1.54999999999999994e90

   1. Initial program 71.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. Taylor expanded in j around 0 71.7%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 71.7%

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

      2. *-commutative 71.7%

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

      3. cancel-sign-sub-inv 71.7%

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

      4. *-commutative 71.7%

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

   4. Simplified 71.7%

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

   5. Taylor expanded in y around inf 64.7%

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

      1. *-commutative 64.7%

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

   7. Simplified 64.7%

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

   if -1.54999999999999994e90 < x < 1.6500000000000001e-302 or 2.00000000000000007e170 < x < 2.24999999999999991e234

   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. Taylor expanded in c around inf 56.4%

      \[\leadsto \color{blue}{c \cdot \left(j \cdot t - b \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 56.4%

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

   4. Simplified 56.4%

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

   if 1.6500000000000001e-302 < x < 1.44999999999999997e64

   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. Taylor expanded in b around inf 56.6%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 56.6%

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

   4. Simplified 56.6%

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

   if 2.24999999999999991e234 < x

   1. Initial program 81.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. Taylor expanded in j around 0 81.4%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 81.4%

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

      2. *-commutative 81.4%

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

      3. cancel-sign-sub-inv 81.4%

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

      4. *-commutative 81.4%

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

   4. Simplified 81.4%

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

   5. Taylor expanded in y around inf 51.5%

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

      1. associate-*r* 57.5%

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

      2. *-commutative 57.5%

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

   7. Simplified 57.5%

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

4. Final simplification 56.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -2.15 \cdot 10^{+161}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq -1.55 \cdot 10^{+90}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;x \leq 1.65 \cdot 10^{-302}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{elif}\;x \leq 1.45 \cdot 10^{+64}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;x \leq 2 \cdot 10^{+170}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;x \leq 2.25 \cdot 10^{+234}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \end{array} \]

Alternative 8: 29.6% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\ t_2 := x \cdot \left(y \cdot z\right)\\ t_3 := t \cdot \left(c \cdot j\right)\\ \mathbf{if}\;c \leq -2 \cdot 10^{+91}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;c \leq -2.35 \cdot 10^{-141}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq -1.1 \cdot 10^{-251}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 1.95 \cdot 10^{-290}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq 1.1 \cdot 10^{-195}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq 3.4 \cdot 10^{-17}:\\ \;\;\;\;i \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;c \leq 10^{+52}:\\ \;\;\;\;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 (* (- a) (* x t))) (t_2 (* x (* y z))) (t_3 (* t (* c j))))
   (if (<= c -2e+91)
     t_3
     (if (<= c -2.35e-141)
       t_1
       (if (<= c -1.1e-251)
         (* b (* a i))
         (if (<= c 1.95e-290)
           t_1
           (if (<= c 1.1e-195)
             t_2
             (if (<= c 3.4e-17) (* i (* a b)) (if (<= c 1e+52) 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 = -a * (x * t);
	double t_2 = x * (y * z);
	double t_3 = t * (c * j);
	double tmp;
	if (c <= -2e+91) {
		tmp = t_3;
	} else if (c <= -2.35e-141) {
		tmp = t_1;
	} else if (c <= -1.1e-251) {
		tmp = b * (a * i);
	} else if (c <= 1.95e-290) {
		tmp = t_1;
	} else if (c <= 1.1e-195) {
		tmp = t_2;
	} else if (c <= 3.4e-17) {
		tmp = i * (a * b);
	} else if (c <= 1e+52) {
		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 = -a * (x * t)
    t_2 = x * (y * z)
    t_3 = t * (c * j)
    if (c <= (-2d+91)) then
        tmp = t_3
    else if (c <= (-2.35d-141)) then
        tmp = t_1
    else if (c <= (-1.1d-251)) then
        tmp = b * (a * i)
    else if (c <= 1.95d-290) then
        tmp = t_1
    else if (c <= 1.1d-195) then
        tmp = t_2
    else if (c <= 3.4d-17) then
        tmp = i * (a * b)
    else if (c <= 1d+52) 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 = -a * (x * t);
	double t_2 = x * (y * z);
	double t_3 = t * (c * j);
	double tmp;
	if (c <= -2e+91) {
		tmp = t_3;
	} else if (c <= -2.35e-141) {
		tmp = t_1;
	} else if (c <= -1.1e-251) {
		tmp = b * (a * i);
	} else if (c <= 1.95e-290) {
		tmp = t_1;
	} else if (c <= 1.1e-195) {
		tmp = t_2;
	} else if (c <= 3.4e-17) {
		tmp = i * (a * b);
	} else if (c <= 1e+52) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = -a * (x * t)
	t_2 = x * (y * z)
	t_3 = t * (c * j)
	tmp = 0
	if c <= -2e+91:
		tmp = t_3
	elif c <= -2.35e-141:
		tmp = t_1
	elif c <= -1.1e-251:
		tmp = b * (a * i)
	elif c <= 1.95e-290:
		tmp = t_1
	elif c <= 1.1e-195:
		tmp = t_2
	elif c <= 3.4e-17:
		tmp = i * (a * b)
	elif c <= 1e+52:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(-a) * Float64(x * t))
	t_2 = Float64(x * Float64(y * z))
	t_3 = Float64(t * Float64(c * j))
	tmp = 0.0
	if (c <= -2e+91)
		tmp = t_3;
	elseif (c <= -2.35e-141)
		tmp = t_1;
	elseif (c <= -1.1e-251)
		tmp = Float64(b * Float64(a * i));
	elseif (c <= 1.95e-290)
		tmp = t_1;
	elseif (c <= 1.1e-195)
		tmp = t_2;
	elseif (c <= 3.4e-17)
		tmp = Float64(i * Float64(a * b));
	elseif (c <= 1e+52)
		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 = -a * (x * t);
	t_2 = x * (y * z);
	t_3 = t * (c * j);
	tmp = 0.0;
	if (c <= -2e+91)
		tmp = t_3;
	elseif (c <= -2.35e-141)
		tmp = t_1;
	elseif (c <= -1.1e-251)
		tmp = b * (a * i);
	elseif (c <= 1.95e-290)
		tmp = t_1;
	elseif (c <= 1.1e-195)
		tmp = t_2;
	elseif (c <= 3.4e-17)
		tmp = i * (a * b);
	elseif (c <= 1e+52)
		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[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2e+91], t$95$3, If[LessEqual[c, -2.35e-141], t$95$1, If[LessEqual[c, -1.1e-251], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.95e-290], t$95$1, If[LessEqual[c, 1.1e-195], t$95$2, If[LessEqual[c, 3.4e-17], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1e+52], t$95$2, t$95$3]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if c < -2.00000000000000016e91 or 9.9999999999999999e51 < c

   1. Initial program 68.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. Taylor expanded in t around -inf 48.3%

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

      1. mul-1-neg 48.3%

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

      2. *-commutative 48.3%

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

      3. distribute-rgt-neg-in 48.3%

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

      4. +-commutative 48.3%

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

      5. mul-1-neg 48.3%

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

      6. unsub-neg 48.3%

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

      7. *-commutative 48.3%

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

      8. *-commutative 48.3%

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

   4. Simplified 48.3%

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

   5. Taylor expanded in x around 0 35.3%

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

      1. associate-*r* 41.0%

         \[\leadsto \color{blue}{\left(c \cdot j\right) \cdot t} \]

      2. *-commutative 41.0%

         \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   7. Simplified 41.0%

      \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   if -2.00000000000000016e91 < c < -2.3499999999999999e-141 or -1.1e-251 < c < 1.94999999999999986e-290

   1. Initial program 84.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. Taylor expanded in j around 0 77.2%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 77.2%

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

      2. *-commutative 77.2%

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

      3. cancel-sign-sub-inv 77.2%

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

      4. *-commutative 77.2%

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

   4. Simplified 77.2%

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

   5. Taylor expanded in t around inf 39.6%

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

      1. mul-1-neg 39.6%

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

      2. distribute-rgt-neg-in 39.6%

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

      3. distribute-rgt-neg-in 39.6%

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

   7. Simplified 39.6%

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

   if -2.3499999999999999e-141 < c < -1.1e-251

   1. Initial program 74.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. Taylor expanded in b around inf 54.4%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 54.4%

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

   4. Simplified 54.4%

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

   5. Taylor expanded in i around inf 47.9%

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

   if 1.94999999999999986e-290 < c < 1.10000000000000003e-195 or 3.3999999999999998e-17 < c < 9.9999999999999999e51

   1. Initial program 86.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. Taylor expanded in j around 0 79.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 79.8%

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

      2. *-commutative 79.8%

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

      3. cancel-sign-sub-inv 79.8%

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

      4. *-commutative 79.8%

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

   4. Simplified 79.8%

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

   5. Taylor expanded in y around inf 45.7%

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

      1. *-commutative 45.7%

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

   7. Simplified 45.7%

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

   if 1.10000000000000003e-195 < c < 3.3999999999999998e-17

   1. Initial program 71.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. Taylor expanded in i around inf 51.4%

      \[\leadsto \color{blue}{i \cdot \left(-1 \cdot \left(j \cdot y\right) - -1 \cdot \left(a \cdot b\right)\right)} \]
   3. Step-by-step derivation

      1. distribute-lft-out-- 51.4%

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

   4. Simplified 51.4%

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

   5. Taylor expanded in j around 0 51.0%

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

      1. neg-mul-1 51.0%

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

      2. distribute-lft-neg-in 51.0%

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

      3. *-commutative 51.0%

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

   7. Simplified 51.0%

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

   8. Taylor expanded in i around 0 48.3%

      \[\leadsto \color{blue}{a \cdot \left(b \cdot i\right)} \]
   9. Step-by-step derivation

      1. associate-*r* 51.0%

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

   10. Simplified 51.0%

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

4. Final simplification 43.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -2 \cdot 10^{+91}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \mathbf{elif}\;c \leq -2.35 \cdot 10^{-141}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;c \leq -1.1 \cdot 10^{-251}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 1.95 \cdot 10^{-290}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;c \leq 1.1 \cdot 10^{-195}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;c \leq 3.4 \cdot 10^{-17}:\\ \;\;\;\;i \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;c \leq 10^{+52}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

Alternative 9: 41.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;b \leq -2.55 \cdot 10^{+40}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -1.1 \cdot 10^{-71}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;b \leq -1.05 \cdot 10^{-138}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -5 \cdot 10^{-292}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;b \leq 6.6 \cdot 10^{-60}:\\ \;\;\;\;z \cdot \left(x \cdot y\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 (* b (- (* a i) (* z c)))))
   (if (<= b -2.55e+40)
     t_1
     (if (<= b -1.1e-71)
       (* x (* y z))
       (if (<= b -1.05e-138)
         t_1
         (if (<= b -5e-292)
           (* (- a) (* x t))
           (if (<= b 6.6e-60) (* z (* x y)) 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 tmp;
	if (b <= -2.55e+40) {
		tmp = t_1;
	} else if (b <= -1.1e-71) {
		tmp = x * (y * z);
	} else if (b <= -1.05e-138) {
		tmp = t_1;
	} else if (b <= -5e-292) {
		tmp = -a * (x * t);
	} else if (b <= 6.6e-60) {
		tmp = z * (x * y);
	} 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 = b * ((a * i) - (z * c))
    if (b <= (-2.55d+40)) then
        tmp = t_1
    else if (b <= (-1.1d-71)) then
        tmp = x * (y * z)
    else if (b <= (-1.05d-138)) then
        tmp = t_1
    else if (b <= (-5d-292)) then
        tmp = -a * (x * t)
    else if (b <= 6.6d-60) then
        tmp = z * (x * y)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -2.55e+40) {
		tmp = t_1;
	} else if (b <= -1.1e-71) {
		tmp = x * (y * z);
	} else if (b <= -1.05e-138) {
		tmp = t_1;
	} else if (b <= -5e-292) {
		tmp = -a * (x * t);
	} else if (b <= 6.6e-60) {
		tmp = z * (x * y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	tmp = 0
	if b <= -2.55e+40:
		tmp = t_1
	elif b <= -1.1e-71:
		tmp = x * (y * z)
	elif b <= -1.05e-138:
		tmp = t_1
	elif b <= -5e-292:
		tmp = -a * (x * t)
	elif b <= 6.6e-60:
		tmp = z * (x * y)
	else:
		tmp = 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)))
	tmp = 0.0
	if (b <= -2.55e+40)
		tmp = t_1;
	elseif (b <= -1.1e-71)
		tmp = Float64(x * Float64(y * z));
	elseif (b <= -1.05e-138)
		tmp = t_1;
	elseif (b <= -5e-292)
		tmp = Float64(Float64(-a) * Float64(x * t));
	elseif (b <= 6.6e-60)
		tmp = Float64(z * Float64(x * y));
	else
		tmp = 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));
	tmp = 0.0;
	if (b <= -2.55e+40)
		tmp = t_1;
	elseif (b <= -1.1e-71)
		tmp = x * (y * z);
	elseif (b <= -1.05e-138)
		tmp = t_1;
	elseif (b <= -5e-292)
		tmp = -a * (x * t);
	elseif (b <= 6.6e-60)
		tmp = z * (x * y);
	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[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.55e+40], t$95$1, If[LessEqual[b, -1.1e-71], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.05e-138], t$95$1, If[LessEqual[b, -5e-292], N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.6e-60], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 4 regimes

2. if b < -2.54999999999999979e40 or -1.09999999999999999e-71 < b < -1.04999999999999993e-138 or 6.5999999999999996e-60 < b

   1. Initial program 76.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. Taylor expanded in b around inf 62.2%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 62.2%

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

   4. Simplified 62.2%

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

   if -2.54999999999999979e40 < b < -1.09999999999999999e-71

   1. Initial program 65.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. Taylor expanded in j around 0 61.3%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 61.3%

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

      2. *-commutative 61.3%

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

      3. cancel-sign-sub-inv 61.3%

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

      4. *-commutative 61.3%

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

   4. Simplified 61.3%

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

   5. Taylor expanded in y around inf 38.1%

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

      1. *-commutative 38.1%

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

   7. Simplified 38.1%

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

   if -1.04999999999999993e-138 < b < -4.99999999999999981e-292

   1. Initial program 80.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. Taylor expanded in j around 0 67.7%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 67.7%

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

      2. *-commutative 67.7%

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

      3. cancel-sign-sub-inv 67.7%

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

      4. *-commutative 67.7%

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

   4. Simplified 67.7%

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

   5. Taylor expanded in t around inf 46.7%

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

      1. mul-1-neg 46.7%

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

      2. distribute-rgt-neg-in 46.7%

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

      3. distribute-rgt-neg-in 46.7%

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

   7. Simplified 46.7%

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

   if -4.99999999999999981e-292 < b < 6.5999999999999996e-60

   1. Initial program 76.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. Taylor expanded in j around 0 57.9%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 57.9%

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

      2. *-commutative 57.9%

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

      3. cancel-sign-sub-inv 57.9%

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

      4. *-commutative 57.9%

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

   4. Simplified 57.9%

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

   5. Taylor expanded in y around inf 38.7%

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

      1. associate-*r* 43.0%

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

      2. *-commutative 43.0%

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

   7. Simplified 43.0%

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

4. Final simplification 54.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2.55 \cdot 10^{+40}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq -1.1 \cdot 10^{-71}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;b \leq -1.05 \cdot 10^{-138}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq -5 \cdot 10^{-292}:\\ \;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\ \mathbf{elif}\;b \leq 6.6 \cdot 10^{-60}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \end{array} \]

Alternative 10: 59.2% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+84} \lor \neg \left(b \leq 1.2 \cdot 10^{+55}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (or (<= b -1e+84) (not (<= b 1.2e+55)))
   (* b (- (* a i) (* z c)))
   (+ (* x (- (* y z) (* t a))) (* c (* t j)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if ((b <= -1e+84) || !(b <= 1.2e+55)) {
		tmp = b * ((a * i) - (z * c));
	} else {
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	}
	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 ((b <= (-1d+84)) .or. (.not. (b <= 1.2d+55))) then
        tmp = b * ((a * i) - (z * c))
    else
        tmp = (x * ((y * z) - (t * a))) + (c * (t * j))
    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 ((b <= -1e+84) || !(b <= 1.2e+55)) {
		tmp = b * ((a * i) - (z * c));
	} else {
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (b <= -1e+84) or not (b <= 1.2e+55):
		tmp = b * ((a * i) - (z * c))
	else:
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if ((b <= -1e+84) || !(b <= 1.2e+55))
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	else
		tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(c * Float64(t * j)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if ((b <= -1e+84) || ~((b <= 1.2e+55)))
		tmp = b * ((a * i) - (z * c));
	else
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -1e+84], N[Not[LessEqual[b, 1.2e+55]], $MachinePrecision]], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.00000000000000006e84 or 1.2e55 < b

   1. Initial program 74.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. Taylor expanded in b around inf 72.8%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 72.8%

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

   4. Simplified 72.8%

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

   if -1.00000000000000006e84 < b < 1.2e55

   1. Initial program 77.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. Taylor expanded in i around 0 68.0%

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

   3. Taylor expanded in b around 0 67.1%

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

4. Final simplification 69.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1 \cdot 10^{+84} \lor \neg \left(b \leq 1.2 \cdot 10^{+55}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ \end{array} \]

Alternative 11: 60.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.22 \cdot 10^{+85} \lor \neg \left(b \leq 9 \cdot 10^{+47}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (or (<= b -1.22e+85) (not (<= b 9e+47)))
   (+ (* b (- (* a i) (* z c))) (* z (* x y)))
   (+ (* x (- (* y z) (* t a))) (* c (* t j)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if ((b <= -1.22e+85) || !(b <= 9e+47)) {
		tmp = (b * ((a * i) - (z * c))) + (z * (x * y));
	} else {
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	}
	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 ((b <= (-1.22d+85)) .or. (.not. (b <= 9d+47))) then
        tmp = (b * ((a * i) - (z * c))) + (z * (x * y))
    else
        tmp = (x * ((y * z) - (t * a))) + (c * (t * j))
    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 ((b <= -1.22e+85) || !(b <= 9e+47)) {
		tmp = (b * ((a * i) - (z * c))) + (z * (x * y));
	} else {
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (b <= -1.22e+85) or not (b <= 9e+47):
		tmp = (b * ((a * i) - (z * c))) + (z * (x * y))
	else:
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if ((b <= -1.22e+85) || !(b <= 9e+47))
		tmp = Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) + Float64(z * Float64(x * y)));
	else
		tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(c * Float64(t * j)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if ((b <= -1.22e+85) || ~((b <= 9e+47)))
		tmp = (b * ((a * i) - (z * c))) + (z * (x * y));
	else
		tmp = (x * ((y * z) - (t * a))) + (c * (t * j));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -1.22e+85], N[Not[LessEqual[b, 9e+47]], $MachinePrecision]], N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.22e85 or 8.99999999999999958e47 < b

   1. Initial program 74.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. Taylor expanded in j around 0 80.6%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 80.6%

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

      2. *-commutative 80.6%

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

      3. cancel-sign-sub-inv 80.6%

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

      4. *-commutative 80.6%

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

   4. Simplified 80.6%

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

   5. Taylor expanded in y around inf 76.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z\right)} - b \cdot \left(c \cdot z - i \cdot a\right) \]
   6. Step-by-step derivation

      1. associate-*r* 79.7%

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

      2. *-commutative 79.7%

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

   7. Simplified 79.7%

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

   if -1.22e85 < b < 8.99999999999999958e47

   1. Initial program 77.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. Taylor expanded in i around 0 67.8%

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

   3. Taylor expanded in b around 0 66.9%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.22 \cdot 10^{+85} \lor \neg \left(b \leq 9 \cdot 10^{+47}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right) + z \cdot \left(x \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ \end{array} \]

Alternative 12: 49.4% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := t \cdot \left(c \cdot j - x \cdot a\right)\\ t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;b \leq -1.15 \cdot 10^{+134}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-300}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 2.2 \cdot 10^{-162}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;b \leq 1.85 \cdot 10^{+52}:\\ \;\;\;\;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 (* t (- (* c j) (* x a)))) (t_2 (* b (- (* a i) (* z c)))))
   (if (<= b -1.15e+134)
     t_2
     (if (<= b 2e-300)
       t_1
       (if (<= b 2.2e-162) (* z (* x y)) (if (<= b 1.85e+52) 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 = t * ((c * j) - (x * a));
	double t_2 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -1.15e+134) {
		tmp = t_2;
	} else if (b <= 2e-300) {
		tmp = t_1;
	} else if (b <= 2.2e-162) {
		tmp = z * (x * y);
	} else if (b <= 1.85e+52) {
		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 = t * ((c * j) - (x * a))
    t_2 = b * ((a * i) - (z * c))
    if (b <= (-1.15d+134)) then
        tmp = t_2
    else if (b <= 2d-300) then
        tmp = t_1
    else if (b <= 2.2d-162) then
        tmp = z * (x * y)
    else if (b <= 1.85d+52) 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 = t * ((c * j) - (x * a));
	double t_2 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -1.15e+134) {
		tmp = t_2;
	} else if (b <= 2e-300) {
		tmp = t_1;
	} else if (b <= 2.2e-162) {
		tmp = z * (x * y);
	} else if (b <= 1.85e+52) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = t * ((c * j) - (x * a))
	t_2 = b * ((a * i) - (z * c))
	tmp = 0
	if b <= -1.15e+134:
		tmp = t_2
	elif b <= 2e-300:
		tmp = t_1
	elif b <= 2.2e-162:
		tmp = z * (x * y)
	elif b <= 1.85e+52:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(t * Float64(Float64(c * j) - Float64(x * a)))
	t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	tmp = 0.0
	if (b <= -1.15e+134)
		tmp = t_2;
	elseif (b <= 2e-300)
		tmp = t_1;
	elseif (b <= 2.2e-162)
		tmp = Float64(z * Float64(x * y));
	elseif (b <= 1.85e+52)
		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 = t * ((c * j) - (x * a));
	t_2 = b * ((a * i) - (z * c));
	tmp = 0.0;
	if (b <= -1.15e+134)
		tmp = t_2;
	elseif (b <= 2e-300)
		tmp = t_1;
	elseif (b <= 2.2e-162)
		tmp = z * (x * y);
	elseif (b <= 1.85e+52)
		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[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.15e+134], t$95$2, If[LessEqual[b, 2e-300], t$95$1, If[LessEqual[b, 2.2e-162], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.85e+52], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if b < -1.1499999999999999e134 or 1.85e52 < b

   1. Initial program 74.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. Taylor expanded in b around inf 74.7%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 74.7%

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

   4. Simplified 74.7%

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

   if -1.1499999999999999e134 < b < 2.00000000000000005e-300 or 2.1999999999999999e-162 < b < 1.85e52

   1. Initial program 78.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. Taylor expanded in c around inf 73.3%

      \[\leadsto \left(x \cdot \left(y \cdot z - t \cdot a\right) - \color{blue}{b \cdot \left(c \cdot z\right)}\right) + j \cdot \left(c \cdot t - i \cdot y\right) \]
   3. Step-by-step derivation

      1. *-commutative 73.3%

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

      2. *-commutative 73.3%

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

      3. associate-*l* 75.3%

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

   4. Simplified 75.3%

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

   5. Taylor expanded in t around inf 50.1%

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

      1. +-commutative 50.1%

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

      2. mul-1-neg 50.1%

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

      3. unsub-neg 50.1%

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

      4. *-commutative 50.1%

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

   7. Simplified 50.1%

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

   if 2.00000000000000005e-300 < b < 2.1999999999999999e-162

   1. Initial program 67.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. Taylor expanded in j around 0 62.5%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 62.5%

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

      2. *-commutative 62.5%

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

      3. cancel-sign-sub-inv 62.5%

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

      4. *-commutative 62.5%

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

   4. Simplified 62.5%

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

   5. Taylor expanded in y around inf 42.3%

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

      1. associate-*r* 51.3%

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

      2. *-commutative 51.3%

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

   7. Simplified 51.3%

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

4. Final simplification 59.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.15 \cdot 10^{+134}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq 2 \cdot 10^{-300}:\\ \;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\ \mathbf{elif}\;b \leq 2.2 \cdot 10^{-162}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;b \leq 1.85 \cdot 10^{+52}:\\ \;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \end{array} \]

Alternative 13: 51.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;b \leq -7.2 \cdot 10^{+42}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 6.8 \cdot 10^{-298}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{-9}:\\ \;\;\;\;z \cdot \left(x \cdot y\right) + c \cdot \left(t \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 (* b (- (* a i) (* z c)))))
   (if (<= b -7.2e+42)
     t_1
     (if (<= b 6.8e-298)
       (* x (- (* y z) (* t a)))
       (if (<= b 3.4e-9) (+ (* z (* x y)) (* c (* t 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 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -7.2e+42) {
		tmp = t_1;
	} else if (b <= 6.8e-298) {
		tmp = x * ((y * z) - (t * a));
	} else if (b <= 3.4e-9) {
		tmp = (z * (x * y)) + (c * (t * 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 = b * ((a * i) - (z * c))
    if (b <= (-7.2d+42)) then
        tmp = t_1
    else if (b <= 6.8d-298) then
        tmp = x * ((y * z) - (t * a))
    else if (b <= 3.4d-9) then
        tmp = (z * (x * y)) + (c * (t * 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 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -7.2e+42) {
		tmp = t_1;
	} else if (b <= 6.8e-298) {
		tmp = x * ((y * z) - (t * a));
	} else if (b <= 3.4e-9) {
		tmp = (z * (x * y)) + (c * (t * j));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = b * ((a * i) - (z * c))
	tmp = 0
	if b <= -7.2e+42:
		tmp = t_1
	elif b <= 6.8e-298:
		tmp = x * ((y * z) - (t * a))
	elif b <= 3.4e-9:
		tmp = (z * (x * y)) + (c * (t * j))
	else:
		tmp = 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)))
	tmp = 0.0
	if (b <= -7.2e+42)
		tmp = t_1;
	elseif (b <= 6.8e-298)
		tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a)));
	elseif (b <= 3.4e-9)
		tmp = Float64(Float64(z * Float64(x * y)) + Float64(c * Float64(t * 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 = b * ((a * i) - (z * c));
	tmp = 0.0;
	if (b <= -7.2e+42)
		tmp = t_1;
	elseif (b <= 6.8e-298)
		tmp = x * ((y * z) - (t * a));
	elseif (b <= 3.4e-9)
		tmp = (z * (x * y)) + (c * (t * 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[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.2e+42], t$95$1, If[LessEqual[b, 6.8e-298], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.4e-9], N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if b < -7.2000000000000002e42 or 3.3999999999999998e-9 < b

   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. Taylor expanded in b around inf 66.1%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 66.1%

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

   4. Simplified 66.1%

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

   if -7.2000000000000002e42 < b < 6.8e-298

   1. Initial program 74.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. Taylor expanded in j around 0 66.5%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 66.5%

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

      2. *-commutative 66.5%

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

      3. cancel-sign-sub-inv 66.5%

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

      4. *-commutative 66.5%

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

   4. Simplified 66.5%

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

   5. Taylor expanded in x around inf 62.5%

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

      1. *-commutative 62.5%

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

   7. Simplified 62.5%

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

   if 6.8e-298 < b < 3.3999999999999998e-9

   1. Initial program 79.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. Taylor expanded in i around 0 65.4%

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

   3. Taylor expanded in b around 0 65.0%

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

   4. Taylor expanded in y around inf 56.6%

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

      1. associate-*r* 62.5%

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

      2. *-commutative 62.5%

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

   6. Simplified 62.5%

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

4. Final simplification 64.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -7.2 \cdot 10^{+42}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;b \leq 6.8 \cdot 10^{-298}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq 3.4 \cdot 10^{-9}:\\ \;\;\;\;z \cdot \left(x \cdot y\right) + c \cdot \left(t \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \end{array} \]

Alternative 14: 29.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z\right)\\ t_2 := t \cdot \left(c \cdot j\right)\\ \mathbf{if}\;c \leq -2.6 \cdot 10^{+103}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq 7.2 \cdot 10^{-293}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 10^{-184}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq 1.7 \cdot 10^{-12}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;c \leq 1.1 \cdot 10^{+52}:\\ \;\;\;\;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_2 (* t (* c j))))
   (if (<= c -2.6e+103)
     t_2
     (if (<= c 7.2e-293)
       (* b (* a i))
       (if (<= c 1e-184)
         t_1
         (if (<= c 1.7e-12) (* a (* b i)) (if (<= c 1.1e+52) 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);
	double t_2 = t * (c * j);
	double tmp;
	if (c <= -2.6e+103) {
		tmp = t_2;
	} else if (c <= 7.2e-293) {
		tmp = b * (a * i);
	} else if (c <= 1e-184) {
		tmp = t_1;
	} else if (c <= 1.7e-12) {
		tmp = a * (b * i);
	} else if (c <= 1.1e+52) {
		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_2 = t * (c * j)
    if (c <= (-2.6d+103)) then
        tmp = t_2
    else if (c <= 7.2d-293) then
        tmp = b * (a * i)
    else if (c <= 1d-184) then
        tmp = t_1
    else if (c <= 1.7d-12) then
        tmp = a * (b * i)
    else if (c <= 1.1d+52) 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);
	double t_2 = t * (c * j);
	double tmp;
	if (c <= -2.6e+103) {
		tmp = t_2;
	} else if (c <= 7.2e-293) {
		tmp = b * (a * i);
	} else if (c <= 1e-184) {
		tmp = t_1;
	} else if (c <= 1.7e-12) {
		tmp = a * (b * i);
	} else if (c <= 1.1e+52) {
		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_2 = t * (c * j)
	tmp = 0
	if c <= -2.6e+103:
		tmp = t_2
	elif c <= 7.2e-293:
		tmp = b * (a * i)
	elif c <= 1e-184:
		tmp = t_1
	elif c <= 1.7e-12:
		tmp = a * (b * i)
	elif c <= 1.1e+52:
		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(y * z))
	t_2 = Float64(t * Float64(c * j))
	tmp = 0.0
	if (c <= -2.6e+103)
		tmp = t_2;
	elseif (c <= 7.2e-293)
		tmp = Float64(b * Float64(a * i));
	elseif (c <= 1e-184)
		tmp = t_1;
	elseif (c <= 1.7e-12)
		tmp = Float64(a * Float64(b * i));
	elseif (c <= 1.1e+52)
		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_2 = t * (c * j);
	tmp = 0.0;
	if (c <= -2.6e+103)
		tmp = t_2;
	elseif (c <= 7.2e-293)
		tmp = b * (a * i);
	elseif (c <= 1e-184)
		tmp = t_1;
	elseif (c <= 1.7e-12)
		tmp = a * (b * i);
	elseif (c <= 1.1e+52)
		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[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2.6e+103], t$95$2, If[LessEqual[c, 7.2e-293], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1e-184], t$95$1, If[LessEqual[c, 1.7e-12], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.1e+52], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if c < -2.6000000000000002e103 or 1.1e52 < c

   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. Taylor expanded in t around -inf 49.3%

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

      1. mul-1-neg 49.3%

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

      2. *-commutative 49.3%

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

      3. distribute-rgt-neg-in 49.3%

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

      4. +-commutative 49.3%

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

      5. mul-1-neg 49.3%

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

      6. unsub-neg 49.3%

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

      7. *-commutative 49.3%

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

      8. *-commutative 49.3%

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

   4. Simplified 49.3%

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

   5. Taylor expanded in x around 0 36.0%

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

      1. associate-*r* 41.7%

         \[\leadsto \color{blue}{\left(c \cdot j\right) \cdot t} \]

      2. *-commutative 41.7%

         \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   7. Simplified 41.7%

      \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   if -2.6000000000000002e103 < c < 7.1999999999999997e-293

   1. Initial program 83.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. Taylor expanded in b around inf 38.0%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 38.0%

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

   4. Simplified 38.0%

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

   5. Taylor expanded in i around inf 31.9%

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

   if 7.1999999999999997e-293 < c < 1.0000000000000001e-184 or 1.7e-12 < c < 1.1e52

   1. Initial program 87.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. Taylor expanded in j around 0 80.7%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 80.7%

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

      2. *-commutative 80.7%

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

      3. cancel-sign-sub-inv 80.7%

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

      4. *-commutative 80.7%

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

   4. Simplified 80.7%

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

   5. Taylor expanded in y around inf 45.9%

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

      1. *-commutative 45.9%

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

   7. Simplified 45.9%

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

   if 1.0000000000000001e-184 < c < 1.7e-12

   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. Taylor expanded in j around 0 72.9%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 72.9%

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

      2. *-commutative 72.9%

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

      3. cancel-sign-sub-inv 72.9%

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

      4. *-commutative 72.9%

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

   4. Simplified 72.9%

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

   5. Taylor expanded in i around inf 48.1%

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

4. Final simplification 40.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -2.6 \cdot 10^{+103}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \mathbf{elif}\;c \leq 7.2 \cdot 10^{-293}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 10^{-184}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;c \leq 1.7 \cdot 10^{-12}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;c \leq 1.1 \cdot 10^{+52}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

Alternative 15: 29.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z\right)\\ t_2 := t \cdot \left(c \cdot j\right)\\ \mathbf{if}\;c \leq -6 \cdot 10^{+105}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq 5.2 \cdot 10^{-294}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 4.6 \cdot 10^{-193}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq 1.65 \cdot 10^{-8}:\\ \;\;\;\;i \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;c \leq 7.2 \cdot 10^{+51}:\\ \;\;\;\;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_2 (* t (* c j))))
   (if (<= c -6e+105)
     t_2
     (if (<= c 5.2e-294)
       (* b (* a i))
       (if (<= c 4.6e-193)
         t_1
         (if (<= c 1.65e-8) (* i (* a b)) (if (<= c 7.2e+51) 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);
	double t_2 = t * (c * j);
	double tmp;
	if (c <= -6e+105) {
		tmp = t_2;
	} else if (c <= 5.2e-294) {
		tmp = b * (a * i);
	} else if (c <= 4.6e-193) {
		tmp = t_1;
	} else if (c <= 1.65e-8) {
		tmp = i * (a * b);
	} else if (c <= 7.2e+51) {
		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_2 = t * (c * j)
    if (c <= (-6d+105)) then
        tmp = t_2
    else if (c <= 5.2d-294) then
        tmp = b * (a * i)
    else if (c <= 4.6d-193) then
        tmp = t_1
    else if (c <= 1.65d-8) then
        tmp = i * (a * b)
    else if (c <= 7.2d+51) 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);
	double t_2 = t * (c * j);
	double tmp;
	if (c <= -6e+105) {
		tmp = t_2;
	} else if (c <= 5.2e-294) {
		tmp = b * (a * i);
	} else if (c <= 4.6e-193) {
		tmp = t_1;
	} else if (c <= 1.65e-8) {
		tmp = i * (a * b);
	} else if (c <= 7.2e+51) {
		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_2 = t * (c * j)
	tmp = 0
	if c <= -6e+105:
		tmp = t_2
	elif c <= 5.2e-294:
		tmp = b * (a * i)
	elif c <= 4.6e-193:
		tmp = t_1
	elif c <= 1.65e-8:
		tmp = i * (a * b)
	elif c <= 7.2e+51:
		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(y * z))
	t_2 = Float64(t * Float64(c * j))
	tmp = 0.0
	if (c <= -6e+105)
		tmp = t_2;
	elseif (c <= 5.2e-294)
		tmp = Float64(b * Float64(a * i));
	elseif (c <= 4.6e-193)
		tmp = t_1;
	elseif (c <= 1.65e-8)
		tmp = Float64(i * Float64(a * b));
	elseif (c <= 7.2e+51)
		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_2 = t * (c * j);
	tmp = 0.0;
	if (c <= -6e+105)
		tmp = t_2;
	elseif (c <= 5.2e-294)
		tmp = b * (a * i);
	elseif (c <= 4.6e-193)
		tmp = t_1;
	elseif (c <= 1.65e-8)
		tmp = i * (a * b);
	elseif (c <= 7.2e+51)
		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[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -6e+105], t$95$2, If[LessEqual[c, 5.2e-294], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4.6e-193], t$95$1, If[LessEqual[c, 1.65e-8], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 7.2e+51], t$95$1, t$95$2]]]]]]]

Derivation

1. Split input into 4 regimes

2. if c < -6.0000000000000001e105 or 7.20000000000000022e51 < c

   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. Taylor expanded in t around -inf 49.3%

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

      1. mul-1-neg 49.3%

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

      2. *-commutative 49.3%

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

      3. distribute-rgt-neg-in 49.3%

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

      4. +-commutative 49.3%

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

      5. mul-1-neg 49.3%

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

      6. unsub-neg 49.3%

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

      7. *-commutative 49.3%

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

      8. *-commutative 49.3%

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

   4. Simplified 49.3%

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

   5. Taylor expanded in x around 0 36.0%

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

      1. associate-*r* 41.7%

         \[\leadsto \color{blue}{\left(c \cdot j\right) \cdot t} \]

      2. *-commutative 41.7%

         \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   7. Simplified 41.7%

      \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   if -6.0000000000000001e105 < c < 5.1999999999999999e-294

   1. Initial program 83.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. Taylor expanded in b around inf 38.0%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 38.0%

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

   4. Simplified 38.0%

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

   5. Taylor expanded in i around inf 31.9%

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

   if 5.1999999999999999e-294 < c < 4.60000000000000017e-193 or 1.64999999999999989e-8 < c < 7.20000000000000022e51

   1. Initial program 86.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. Taylor expanded in j around 0 79.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 79.8%

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

      2. *-commutative 79.8%

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

      3. cancel-sign-sub-inv 79.8%

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

      4. *-commutative 79.8%

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

   4. Simplified 79.8%

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

   5. Taylor expanded in y around inf 45.7%

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

      1. *-commutative 45.7%

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

   7. Simplified 45.7%

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

   if 4.60000000000000017e-193 < c < 1.64999999999999989e-8

   1. Initial program 71.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. Taylor expanded in i around inf 51.4%

      \[\leadsto \color{blue}{i \cdot \left(-1 \cdot \left(j \cdot y\right) - -1 \cdot \left(a \cdot b\right)\right)} \]
   3. Step-by-step derivation

      1. distribute-lft-out-- 51.4%

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

   4. Simplified 51.4%

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

   5. Taylor expanded in j around 0 51.0%

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

      1. neg-mul-1 51.0%

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

      2. distribute-lft-neg-in 51.0%

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

      3. *-commutative 51.0%

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

   7. Simplified 51.0%

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

   8. Taylor expanded in i around 0 48.3%

      \[\leadsto \color{blue}{a \cdot \left(b \cdot i\right)} \]
   9. Step-by-step derivation

      1. associate-*r* 51.0%

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

   10. Simplified 51.0%

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

4. Final simplification 40.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -6 \cdot 10^{+105}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \mathbf{elif}\;c \leq 5.2 \cdot 10^{-294}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;c \leq 4.6 \cdot 10^{-193}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;c \leq 1.65 \cdot 10^{-8}:\\ \;\;\;\;i \cdot \left(a \cdot b\right)\\ \mathbf{elif}\;c \leq 7.2 \cdot 10^{+51}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

Alternative 16: 51.6% accurate, 2.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.1 \cdot 10^{+43} \lor \neg \left(b \leq 4.6 \cdot 10^{-38}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (or (<= b -1.1e+43) (not (<= b 4.6e-38)))
   (* b (- (* a i) (* z c)))
   (* x (- (* y z) (* t a)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if ((b <= -1.1e+43) || !(b <= 4.6e-38)) {
		tmp = b * ((a * i) - (z * c));
	} else {
		tmp = x * ((y * z) - (t * a));
	}
	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 ((b <= (-1.1d+43)) .or. (.not. (b <= 4.6d-38))) then
        tmp = b * ((a * i) - (z * c))
    else
        tmp = x * ((y * z) - (t * a))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if ((b <= -1.1e+43) || !(b <= 4.6e-38)) {
		tmp = b * ((a * i) - (z * c));
	} else {
		tmp = x * ((y * z) - (t * a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (b <= -1.1e+43) or not (b <= 4.6e-38):
		tmp = b * ((a * i) - (z * c))
	else:
		tmp = x * ((y * z) - (t * a))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if ((b <= -1.1e+43) || !(b <= 4.6e-38))
		tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c)));
	else
		tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if ((b <= -1.1e+43) || ~((b <= 4.6e-38)))
		tmp = b * ((a * i) - (z * c));
	else
		tmp = x * ((y * z) - (t * a));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if b < -1.1e43 or 4.60000000000000003e-38 < b

   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. Taylor expanded in b around inf 64.5%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 64.5%

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

   4. Simplified 64.5%

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

   if -1.1e43 < b < 4.60000000000000003e-38

   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. Taylor expanded in j around 0 63.8%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 63.8%

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

      2. *-commutative 63.8%

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

      3. cancel-sign-sub-inv 63.8%

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

      4. *-commutative 63.8%

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

   4. Simplified 63.8%

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

   5. Taylor expanded in x around inf 57.2%

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

      1. *-commutative 57.2%

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

   7. Simplified 57.2%

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

4. Final simplification 61.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -1.1 \cdot 10^{+43} \lor \neg \left(b \leq 4.6 \cdot 10^{-38}\right):\\ \;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\ \end{array} \]

Alternative 17: 29.5% accurate, 3.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -14500000 \lor \neg \left(c \leq 6 \cdot 10^{+52}\right):\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (or (<= c -14500000.0) (not (<= c 6e+52))) (* c (* t j)) (* a (* b i))))

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 <= -14500000.0) || !(c <= 6e+52)) {
		tmp = c * (t * j);
	} else {
		tmp = a * (b * i);
	}
	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 <= (-14500000.0d0)) .or. (.not. (c <= 6d+52))) then
        tmp = c * (t * j)
    else
        tmp = a * (b * i)
    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 <= -14500000.0) || !(c <= 6e+52)) {
		tmp = c * (t * j);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (c <= -14500000.0) or not (c <= 6e+52):
		tmp = c * (t * j)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if ((c <= -14500000.0) || !(c <= 6e+52))
		tmp = Float64(c * Float64(t * j));
	else
		tmp = Float64(a * Float64(b * i));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if ((c <= -14500000.0) || ~((c <= 6e+52)))
		tmp = c * (t * j);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -1.45e7 or 6e52 < c

   1. Initial program 68.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. Taylor expanded in t around -inf 50.3%

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

      1. mul-1-neg 50.3%

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

      2. *-commutative 50.3%

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

      3. distribute-rgt-neg-in 50.3%

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

      4. +-commutative 50.3%

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

      5. mul-1-neg 50.3%

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

      6. unsub-neg 50.3%

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

      7. *-commutative 50.3%

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

      8. *-commutative 50.3%

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

   4. Simplified 50.3%

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

   5. Taylor expanded in x around 0 34.1%

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

      1. *-commutative 34.1%

         \[\leadsto c \cdot \color{blue}{\left(t \cdot j\right)} \]

   7. Simplified 34.1%

      \[\leadsto \color{blue}{c \cdot \left(t \cdot j\right)} \]

   if -1.45e7 < c < 6e52

   1. Initial program 82.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. Taylor expanded in j around 0 75.1%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 75.1%

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

      2. *-commutative 75.1%

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

      3. cancel-sign-sub-inv 75.1%

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

      4. *-commutative 75.1%

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

   4. Simplified 75.1%

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

   5. Taylor expanded in i around inf 31.2%

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

4. Final simplification 32.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -14500000 \lor \neg \left(c \leq 6 \cdot 10^{+52}\right):\\ \;\;\;\;c \cdot \left(t \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \]

Alternative 18: 30.2% accurate, 3.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -100000000 \lor \neg \left(c \leq 2.7 \cdot 10^{+52}\right):\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (or (<= c -100000000.0) (not (<= c 2.7e+52)))
   (* t (* c j))
   (* a (* b i))))

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 <= -100000000.0) || !(c <= 2.7e+52)) {
		tmp = t * (c * j);
	} else {
		tmp = a * (b * i);
	}
	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 <= (-100000000.0d0)) .or. (.not. (c <= 2.7d+52))) then
        tmp = t * (c * j)
    else
        tmp = a * (b * i)
    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 <= -100000000.0) || !(c <= 2.7e+52)) {
		tmp = t * (c * j);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (c <= -100000000.0) or not (c <= 2.7e+52):
		tmp = t * (c * j)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if ((c <= -100000000.0) || !(c <= 2.7e+52))
		tmp = Float64(t * Float64(c * j));
	else
		tmp = Float64(a * Float64(b * i));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if ((c <= -100000000.0) || ~((c <= 2.7e+52)))
		tmp = t * (c * j);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if c < -1e8 or 2.7e52 < c

   1. Initial program 68.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. Taylor expanded in t around -inf 50.3%

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

      1. mul-1-neg 50.3%

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

      2. *-commutative 50.3%

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

      3. distribute-rgt-neg-in 50.3%

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

      4. +-commutative 50.3%

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

      5. mul-1-neg 50.3%

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

      6. unsub-neg 50.3%

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

      7. *-commutative 50.3%

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

      8. *-commutative 50.3%

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

   4. Simplified 50.3%

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

   5. Taylor expanded in x around 0 34.1%

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

      1. associate-*r* 38.9%

         \[\leadsto \color{blue}{\left(c \cdot j\right) \cdot t} \]

      2. *-commutative 38.9%

         \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   7. Simplified 38.9%

      \[\leadsto \color{blue}{t \cdot \left(c \cdot j\right)} \]

   if -1e8 < c < 2.7e52

   1. Initial program 82.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. Taylor expanded in j around 0 75.1%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 75.1%

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

      2. *-commutative 75.1%

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

      3. cancel-sign-sub-inv 75.1%

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

      4. *-commutative 75.1%

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

   4. Simplified 75.1%

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

   5. Taylor expanded in i around inf 31.2%

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

4. Final simplification 34.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;c \leq -100000000 \lor \neg \left(c \leq 2.7 \cdot 10^{+52}\right):\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \]

Alternative 19: 22.7% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -5 \cdot 10^{-178}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= x -5e-178) (* b (* a i)) (* a (* b i))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (x <= -5e-178) {
		tmp = b * (a * i);
	} else {
		tmp = a * (b * i);
	}
	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 (x <= (-5d-178)) then
        tmp = b * (a * i)
    else
        tmp = a * (b * i)
    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 (x <= -5e-178) {
		tmp = b * (a * i);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if x <= -5e-178:
		tmp = b * (a * i)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (x <= -5e-178)
		tmp = Float64(b * Float64(a * i));
	else
		tmp = Float64(a * Float64(b * i));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (x <= -5e-178)
		tmp = b * (a * i);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -5e-178], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -4.99999999999999976e-178

   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. Taylor expanded in b around inf 35.0%

      \[\leadsto \color{blue}{b \cdot \left(a \cdot i - c \cdot z\right)} \]
   3. Step-by-step derivation

      1. *-commutative 35.0%

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

   4. Simplified 35.0%

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

   5. Taylor expanded in i around inf 21.1%

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

   if -4.99999999999999976e-178 < x

   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. Taylor expanded in j around 0 65.4%

      \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
   3. Step-by-step derivation

      1. cancel-sign-sub-inv 65.4%

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

      2. *-commutative 65.4%

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

      3. cancel-sign-sub-inv 65.4%

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

      4. *-commutative 65.4%

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

   4. Simplified 65.4%

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

   5. Taylor expanded in i around inf 28.6%

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

4. Final simplification 25.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -5 \cdot 10^{-178}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \end{array} \]

Alternative 20: 22.5% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

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 * (b * i)
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 * (b * i);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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. Taylor expanded in j around 0 68.3%

   \[\leadsto \color{blue}{x \cdot \left(y \cdot z - a \cdot t\right) - b \cdot \left(c \cdot z - a \cdot i\right)} \]
3. Step-by-step derivation

   1. cancel-sign-sub-inv 68.3%

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

   2. *-commutative 68.3%

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

   3. cancel-sign-sub-inv 68.3%

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

   4. *-commutative 68.3%

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

4. Simplified 68.3%

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

5. Taylor expanded in i around inf 23.8%

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

6. Final simplification 23.8%

   \[\leadsto a \cdot \left(b \cdot i\right) \]

Developer target: 69.6% 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 2023320 
(FPCore (x y z t a b c i j)
  :name "Linear.Matrix:det33 from linear-1.19.1.3"
  :precision binary64

  :herbie-target
  (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)))))