Linear.Matrix:det33 from linear-1.19.1.3

Percentage Accurate: 74.4% → 82.0%

Time: 33.7s

Alternatives: 24

Speedup: 0.5×

• 57.7% 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: 74.4% 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.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 61.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ t_2 := x \cdot \left(y \cdot z - t \cdot a\right)\\ t_3 := z \cdot \left(x \cdot y - b \cdot c\right)\\ \mathbf{if}\;z \leq -1.45 \cdot 10^{+129}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq -5.2 \cdot 10^{+41}:\\ \;\;\;\;t_2 + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;z \leq 4.6 \cdot 10^{-78}:\\ \;\;\;\;t \cdot \left(c \cdot j\right) - \left(x \cdot \left(t \cdot a - y \cdot z\right) - i \cdot \left(a \cdot b\right)\right)\\ \mathbf{elif}\;z \leq 1.25 \cdot 10^{-19}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 5600:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{elif}\;z \leq 3.5 \cdot 10^{+50}:\\ \;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{+50}:\\ \;\;\;\;c \cdot \left(z \cdot \left(-b\right)\right)\\ \mathbf{elif}\;z \leq 7.5 \cdot 10^{+125}:\\ \;\;\;\;t_1 + 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 (* j (- (* t c) (* y i))))
        (t_2 (* x (- (* y z) (* t a))))
        (t_3 (* z (- (* x y) (* b c)))))
   (if (<= z -1.45e+129)
     t_3
     (if (<= z -5.2e+41)
       (+ t_2 (* b (- (* a i) (* z c))))
       (if (<= z 4.6e-78)
         (- (* t (* c j)) (- (* x (- (* t a) (* y z))) (* i (* a b))))
         (if (<= z 1.25e-19)
           t_1
           (if (<= z 5600.0)
             (* c (- (* t j) (* z b)))
             (if (<= z 3.5e+50)
               (* i (- (* a b) (* y j)))
               (if (<= z 5.5e+50)
                 (* c (* z (- b)))
                 (if (<= z 7.5e+125) (+ t_1 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 = j * ((t * c) - (y * i));
	double t_2 = x * ((y * z) - (t * a));
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -1.45e+129) {
		tmp = t_3;
	} else if (z <= -5.2e+41) {
		tmp = t_2 + (b * ((a * i) - (z * c)));
	} else if (z <= 4.6e-78) {
		tmp = (t * (c * j)) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	} else if (z <= 1.25e-19) {
		tmp = t_1;
	} else if (z <= 5600.0) {
		tmp = c * ((t * j) - (z * b));
	} else if (z <= 3.5e+50) {
		tmp = i * ((a * b) - (y * j));
	} else if (z <= 5.5e+50) {
		tmp = c * (z * -b);
	} else if (z <= 7.5e+125) {
		tmp = t_1 + 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 = j * ((t * c) - (y * i))
    t_2 = x * ((y * z) - (t * a))
    t_3 = z * ((x * y) - (b * c))
    if (z <= (-1.45d+129)) then
        tmp = t_3
    else if (z <= (-5.2d+41)) then
        tmp = t_2 + (b * ((a * i) - (z * c)))
    else if (z <= 4.6d-78) then
        tmp = (t * (c * j)) - ((x * ((t * a) - (y * z))) - (i * (a * b)))
    else if (z <= 1.25d-19) then
        tmp = t_1
    else if (z <= 5600.0d0) then
        tmp = c * ((t * j) - (z * b))
    else if (z <= 3.5d+50) then
        tmp = i * ((a * b) - (y * j))
    else if (z <= 5.5d+50) then
        tmp = c * (z * -b)
    else if (z <= 7.5d+125) then
        tmp = t_1 + 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 = j * ((t * c) - (y * i));
	double t_2 = x * ((y * z) - (t * a));
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -1.45e+129) {
		tmp = t_3;
	} else if (z <= -5.2e+41) {
		tmp = t_2 + (b * ((a * i) - (z * c)));
	} else if (z <= 4.6e-78) {
		tmp = (t * (c * j)) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	} else if (z <= 1.25e-19) {
		tmp = t_1;
	} else if (z <= 5600.0) {
		tmp = c * ((t * j) - (z * b));
	} else if (z <= 3.5e+50) {
		tmp = i * ((a * b) - (y * j));
	} else if (z <= 5.5e+50) {
		tmp = c * (z * -b);
	} else if (z <= 7.5e+125) {
		tmp = t_1 + t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	t_2 = x * ((y * z) - (t * a))
	t_3 = z * ((x * y) - (b * c))
	tmp = 0
	if z <= -1.45e+129:
		tmp = t_3
	elif z <= -5.2e+41:
		tmp = t_2 + (b * ((a * i) - (z * c)))
	elif z <= 4.6e-78:
		tmp = (t * (c * j)) - ((x * ((t * a) - (y * z))) - (i * (a * b)))
	elif z <= 1.25e-19:
		tmp = t_1
	elif z <= 5600.0:
		tmp = c * ((t * j) - (z * b))
	elif z <= 3.5e+50:
		tmp = i * ((a * b) - (y * j))
	elif z <= 5.5e+50:
		tmp = c * (z * -b)
	elif z <= 7.5e+125:
		tmp = t_1 + t_2
	else:
		tmp = t_3
	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(x * Float64(Float64(y * z) - Float64(t * a)))
	t_3 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	tmp = 0.0
	if (z <= -1.45e+129)
		tmp = t_3;
	elseif (z <= -5.2e+41)
		tmp = Float64(t_2 + Float64(b * Float64(Float64(a * i) - Float64(z * c))));
	elseif (z <= 4.6e-78)
		tmp = Float64(Float64(t * Float64(c * j)) - Float64(Float64(x * Float64(Float64(t * a) - Float64(y * z))) - Float64(i * Float64(a * b))));
	elseif (z <= 1.25e-19)
		tmp = t_1;
	elseif (z <= 5600.0)
		tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b)));
	elseif (z <= 3.5e+50)
		tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j)));
	elseif (z <= 5.5e+50)
		tmp = Float64(c * Float64(z * Float64(-b)));
	elseif (z <= 7.5e+125)
		tmp = Float64(t_1 + 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 = j * ((t * c) - (y * i));
	t_2 = x * ((y * z) - (t * a));
	t_3 = z * ((x * y) - (b * c));
	tmp = 0.0;
	if (z <= -1.45e+129)
		tmp = t_3;
	elseif (z <= -5.2e+41)
		tmp = t_2 + (b * ((a * i) - (z * c)));
	elseif (z <= 4.6e-78)
		tmp = (t * (c * j)) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	elseif (z <= 1.25e-19)
		tmp = t_1;
	elseif (z <= 5600.0)
		tmp = c * ((t * j) - (z * b));
	elseif (z <= 3.5e+50)
		tmp = i * ((a * b) - (y * j));
	elseif (z <= 5.5e+50)
		tmp = c * (z * -b);
	elseif (z <= 7.5e+125)
		tmp = t_1 + 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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $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[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.45e+129], t$95$3, If[LessEqual[z, -5.2e+41], N[(t$95$2 + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.6e-78], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.25e-19], t$95$1, If[LessEqual[z, 5600.0], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.5e+50], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e+50], N[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.5e+125], N[(t$95$1 + t$95$2), $MachinePrecision], t$95$3]]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 61.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ t_2 := z \cdot \left(x \cdot y - b \cdot c\right)\\ \mathbf{if}\;z \leq -3.3 \cdot 10^{+122}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq -4 \cdot 10^{+37}:\\ \;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;z \leq -8.2 \cdot 10^{-141}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{-77}:\\ \;\;\;\;t \cdot \left(c \cdot j\right) + \left(i \cdot \left(a \cdot b\right) - a \cdot \left(x \cdot t\right)\right)\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{+125}:\\ \;\;\;\;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 (+ (* j (- (* t c) (* y i))) (* x (- (* y z) (* t a)))))
        (t_2 (* z (- (* x y) (* b c)))))
   (if (<= z -3.3e+122)
     t_2
     (if (<= z -4e+37)
       (+ (* x (* y z)) (* b (- (* a i) (* z c))))
       (if (<= z -8.2e-141)
         t_1
         (if (<= z 5.5e-77)
           (+ (* t (* c j)) (- (* i (* a b)) (* a (* x t))))
           (if (<= z 4.5e+125) 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 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	double t_2 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -3.3e+122) {
		tmp = t_2;
	} else if (z <= -4e+37) {
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	} else if (z <= -8.2e-141) {
		tmp = t_1;
	} else if (z <= 5.5e-77) {
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	} else if (z <= 4.5e+125) {
		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 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
    t_2 = z * ((x * y) - (b * c))
    if (z <= (-3.3d+122)) then
        tmp = t_2
    else if (z <= (-4d+37)) then
        tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
    else if (z <= (-8.2d-141)) then
        tmp = t_1
    else if (z <= 5.5d-77) then
        tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)))
    else if (z <= 4.5d+125) 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 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	double t_2 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -3.3e+122) {
		tmp = t_2;
	} else if (z <= -4e+37) {
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	} else if (z <= -8.2e-141) {
		tmp = t_1;
	} else if (z <= 5.5e-77) {
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	} else if (z <= 4.5e+125) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
	t_2 = z * ((x * y) - (b * c))
	tmp = 0
	if z <= -3.3e+122:
		tmp = t_2
	elif z <= -4e+37:
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
	elif z <= -8.2e-141:
		tmp = t_1
	elif z <= 5.5e-77:
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)))
	elif z <= 4.5e+125:
		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(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(x * Float64(Float64(y * z) - Float64(t * a))))
	t_2 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	tmp = 0.0
	if (z <= -3.3e+122)
		tmp = t_2;
	elseif (z <= -4e+37)
		tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c))));
	elseif (z <= -8.2e-141)
		tmp = t_1;
	elseif (z <= 5.5e-77)
		tmp = Float64(Float64(t * Float64(c * j)) + Float64(Float64(i * Float64(a * b)) - Float64(a * Float64(x * t))));
	elseif (z <= 4.5e+125)
		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 = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	t_2 = z * ((x * y) - (b * c));
	tmp = 0.0;
	if (z <= -3.3e+122)
		tmp = t_2;
	elseif (z <= -4e+37)
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	elseif (z <= -8.2e-141)
		tmp = t_1;
	elseif (z <= 5.5e-77)
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	elseif (z <= 4.5e+125)
		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[(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]}, Block[{t$95$2 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.3e+122], t$95$2, If[LessEqual[z, -4e+37], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8.2e-141], t$95$1, If[LessEqual[z, 5.5e-77], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e+125], t$95$1, t$95$2]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 62.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\ t_2 := j \cdot \left(t \cdot c - y \cdot i\right) + t_1\\ t_3 := z \cdot \left(x \cdot y - b \cdot c\right)\\ \mathbf{if}\;z \leq -6.5 \cdot 10^{+126}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq -1.4 \cdot 10^{-47}:\\ \;\;\;\;t_1 + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;z \leq -4.3 \cdot 10^{-143}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq 4.8 \cdot 10^{-76}:\\ \;\;\;\;t \cdot \left(c \cdot j\right) + \left(i \cdot \left(a \cdot b\right) - a \cdot \left(x \cdot t\right)\right)\\ \mathbf{elif}\;z \leq 1.8 \cdot 10^{+126}:\\ \;\;\;\;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 (* x (- (* y z) (* t a))))
        (t_2 (+ (* j (- (* t c) (* y i))) t_1))
        (t_3 (* z (- (* x y) (* b c)))))
   (if (<= z -6.5e+126)
     t_3
     (if (<= z -1.4e-47)
       (+ t_1 (* b (- (* a i) (* z c))))
       (if (<= z -4.3e-143)
         t_2
         (if (<= z 4.8e-76)
           (+ (* t (* c j)) (- (* i (* a b)) (* a (* x t))))
           (if (<= z 1.8e+126) 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 = x * ((y * z) - (t * a));
	double t_2 = (j * ((t * c) - (y * i))) + t_1;
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -6.5e+126) {
		tmp = t_3;
	} else if (z <= -1.4e-47) {
		tmp = t_1 + (b * ((a * i) - (z * c)));
	} else if (z <= -4.3e-143) {
		tmp = t_2;
	} else if (z <= 4.8e-76) {
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	} else if (z <= 1.8e+126) {
		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 = x * ((y * z) - (t * a))
    t_2 = (j * ((t * c) - (y * i))) + t_1
    t_3 = z * ((x * y) - (b * c))
    if (z <= (-6.5d+126)) then
        tmp = t_3
    else if (z <= (-1.4d-47)) then
        tmp = t_1 + (b * ((a * i) - (z * c)))
    else if (z <= (-4.3d-143)) then
        tmp = t_2
    else if (z <= 4.8d-76) then
        tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)))
    else if (z <= 1.8d+126) 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 = x * ((y * z) - (t * a));
	double t_2 = (j * ((t * c) - (y * i))) + t_1;
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -6.5e+126) {
		tmp = t_3;
	} else if (z <= -1.4e-47) {
		tmp = t_1 + (b * ((a * i) - (z * c)));
	} else if (z <= -4.3e-143) {
		tmp = t_2;
	} else if (z <= 4.8e-76) {
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	} else if (z <= 1.8e+126) {
		tmp = t_2;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = x * ((y * z) - (t * a))
	t_2 = (j * ((t * c) - (y * i))) + t_1
	t_3 = z * ((x * y) - (b * c))
	tmp = 0
	if z <= -6.5e+126:
		tmp = t_3
	elif z <= -1.4e-47:
		tmp = t_1 + (b * ((a * i) - (z * c)))
	elif z <= -4.3e-143:
		tmp = t_2
	elif z <= 4.8e-76:
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)))
	elif z <= 1.8e+126:
		tmp = t_2
	else:
		tmp = t_3
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a)))
	t_2 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + t_1)
	t_3 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	tmp = 0.0
	if (z <= -6.5e+126)
		tmp = t_3;
	elseif (z <= -1.4e-47)
		tmp = Float64(t_1 + Float64(b * Float64(Float64(a * i) - Float64(z * c))));
	elseif (z <= -4.3e-143)
		tmp = t_2;
	elseif (z <= 4.8e-76)
		tmp = Float64(Float64(t * Float64(c * j)) + Float64(Float64(i * Float64(a * b)) - Float64(a * Float64(x * t))));
	elseif (z <= 1.8e+126)
		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 = x * ((y * z) - (t * a));
	t_2 = (j * ((t * c) - (y * i))) + t_1;
	t_3 = z * ((x * y) - (b * c));
	tmp = 0.0;
	if (z <= -6.5e+126)
		tmp = t_3;
	elseif (z <= -1.4e-47)
		tmp = t_1 + (b * ((a * i) - (z * c)));
	elseif (z <= -4.3e-143)
		tmp = t_2;
	elseif (z <= 4.8e-76)
		tmp = (t * (c * j)) + ((i * (a * b)) - (a * (x * t)));
	elseif (z <= 1.8e+126)
		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[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.5e+126], t$95$3, If[LessEqual[z, -1.4e-47], N[(t$95$1 + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.3e-143], t$95$2, If[LessEqual[z, 4.8e-76], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision] - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.8e+126], t$95$2, t$95$3]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 71.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;b \leq -1.85 \cdot 10^{+232}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 5 \cdot 10^{+80}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - \left(x \cdot \left(t \cdot a - y \cdot z\right) - i \cdot \left(a \cdot b\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(y \cdot z\right) + 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 -1.85e+232)
     t_1
     (if (<= b 5e+80)
       (-
        (* j (- (* t c) (* y i)))
        (- (* x (- (* t a) (* y z))) (* i (* a b))))
       (+ (* x (* y z)) 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 <= -1.85e+232) {
		tmp = t_1;
	} else if (b <= 5e+80) {
		tmp = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	} else {
		tmp = (x * (y * z)) + 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 <= (-1.85d+232)) then
        tmp = t_1
    else if (b <= 5d+80) then
        tmp = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (i * (a * b)))
    else
        tmp = (x * (y * z)) + t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -1.85e+232) {
		tmp = t_1;
	} else if (b <= 5e+80) {
		tmp = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	} else {
		tmp = (x * (y * z)) + 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 <= -1.85e+232:
		tmp = t_1
	elif b <= 5e+80:
		tmp = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (i * (a * b)))
	else:
		tmp = (x * (y * z)) + 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 <= -1.85e+232)
		tmp = t_1;
	elseif (b <= 5e+80)
		tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(Float64(x * Float64(Float64(t * a) - Float64(y * z))) - Float64(i * Float64(a * b))));
	else
		tmp = Float64(Float64(x * Float64(y * z)) + 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 <= -1.85e+232)
		tmp = t_1;
	elseif (b <= 5e+80)
		tmp = (j * ((t * c) - (y * i))) - ((x * ((t * a) - (y * z))) - (i * (a * b)));
	else
		tmp = (x * (y * z)) + 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, -1.85e+232], t$95$1, If[LessEqual[b, 5e+80], 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[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 64.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(x \cdot \left(y \cdot z\right) + a \cdot \left(b \cdot i - x \cdot t\right)\right) - b \cdot \left(z \cdot c\right)\\ \mathbf{if}\;a \leq -1.12 \cdot 10^{-37}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;a \leq -2.2 \cdot 10^{-138}:\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{elif}\;a \leq 4.2 \cdot 10^{-60}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (- (+ (* x (* y z)) (* a (- (* b i) (* x t)))) (* b (* z c)))))
   (if (<= a -1.12e-37)
     t_1
     (if (<= a -2.2e-138)
       (* c (- (* t j) (* z b)))
       (if (<= a 4.2e-60)
         (+ (* j (- (* t c) (* y i))) (* x (- (* y z) (* t a))))
         t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = ((x * (y * z)) + (a * ((b * i) - (x * t)))) - (b * (z * c));
	double tmp;
	if (a <= -1.12e-37) {
		tmp = t_1;
	} else if (a <= -2.2e-138) {
		tmp = c * ((t * j) - (z * b));
	} else if (a <= 4.2e-60) {
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = ((x * (y * z)) + (a * ((b * i) - (x * t)))) - (b * (z * c))
    if (a <= (-1.12d-37)) then
        tmp = t_1
    else if (a <= (-2.2d-138)) then
        tmp = c * ((t * j) - (z * b))
    else if (a <= 4.2d-60) then
        tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = ((x * (y * z)) + (a * ((b * i) - (x * t)))) - (b * (z * c));
	double tmp;
	if (a <= -1.12e-37) {
		tmp = t_1;
	} else if (a <= -2.2e-138) {
		tmp = c * ((t * j) - (z * b));
	} else if (a <= 4.2e-60) {
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = ((x * (y * z)) + (a * ((b * i) - (x * t)))) - (b * (z * c))
	tmp = 0
	if a <= -1.12e-37:
		tmp = t_1
	elif a <= -2.2e-138:
		tmp = c * ((t * j) - (z * b))
	elif a <= 4.2e-60:
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(Float64(x * Float64(y * z)) + Float64(a * Float64(Float64(b * i) - Float64(x * t)))) - Float64(b * Float64(z * c)))
	tmp = 0.0
	if (a <= -1.12e-37)
		tmp = t_1;
	elseif (a <= -2.2e-138)
		tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b)));
	elseif (a <= 4.2e-60)
		tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(x * Float64(Float64(y * z) - Float64(t * a))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = ((x * (y * z)) + (a * ((b * i) - (x * t)))) - (b * (z * c));
	tmp = 0.0;
	if (a <= -1.12e-37)
		tmp = t_1;
	elseif (a <= -2.2e-138)
		tmp = c * ((t * j) - (z * b));
	elseif (a <= 4.2e-60)
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.12e-37], t$95$1, If[LessEqual[a, -2.2e-138], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.2e-60], 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], t$95$1]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 64.1% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \left(x \cdot y - b \cdot c\right)\\ \mathbf{if}\;z \leq -8.5 \cdot 10^{+129}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -5 \cdot 10^{+40}:\\ \;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{elif}\;z \leq 2.15 \cdot 10^{+126}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* z (- (* x y) (* b c)))))
   (if (<= z -8.5e+129)
     t_1
     (if (<= z -5e+40)
       (+ (* x (* y z)) (* b (- (* a i) (* z c))))
       (if (<= z 2.15e+126)
         (+ (* j (- (* t c) (* y i))) (* x (- (* y z) (* t a))))
         t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -8.5e+129) {
		tmp = t_1;
	} else if (z <= -5e+40) {
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	} else if (z <= 2.15e+126) {
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = z * ((x * y) - (b * c))
    if (z <= (-8.5d+129)) then
        tmp = t_1
    else if (z <= (-5d+40)) then
        tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
    else if (z <= 2.15d+126) then
        tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -8.5e+129) {
		tmp = t_1;
	} else if (z <= -5e+40) {
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	} else if (z <= 2.15e+126) {
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = z * ((x * y) - (b * c))
	tmp = 0
	if z <= -8.5e+129:
		tmp = t_1
	elif z <= -5e+40:
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
	elif z <= 2.15e+126:
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	tmp = 0.0
	if (z <= -8.5e+129)
		tmp = t_1;
	elseif (z <= -5e+40)
		tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c))));
	elseif (z <= 2.15e+126)
		tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(x * Float64(Float64(y * z) - Float64(t * a))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = z * ((x * y) - (b * c));
	tmp = 0.0;
	if (z <= -8.5e+129)
		tmp = t_1;
	elseif (z <= -5e+40)
		tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
	elseif (z <= 2.15e+126)
		tmp = (j * ((t * c) - (y * i))) + (x * ((y * z) - (t * a)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.5e+129], t$95$1, If[LessEqual[z, -5e+40], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.15e+126], 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], t$95$1]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 41.6% accurate, 1.2× 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\right)\\ \mathbf{if}\;z \leq -1.6 \cdot 10^{+267}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq -4.4 \cdot 10^{+210}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -2 \cdot 10^{+158}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;z \leq -3.2 \cdot 10^{+38}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 5.8 \cdot 10^{-78}:\\ \;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;z \leq 8.2 \cdot 10^{+107}:\\ \;\;\;\;j \cdot \left(-y \cdot i\right)\\ \mathbf{elif}\;z \leq 7 \cdot 10^{+248}:\\ \;\;\;\;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 (* b (- (* a i) (* z c)))) (t_2 (* x (* y z))))
   (if (<= z -1.6e+267)
     t_2
     (if (<= z -4.4e+210)
       t_1
       (if (<= z -2e+158)
         (* y (* x z))
         (if (<= z -3.2e+38)
           t_1
           (if (<= z 5.8e-78)
             (* a (- (* b i) (* x t)))
             (if (<= z 8.2e+107)
               (* j (- (* y i)))
               (if (<= z 7e+248) 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 = b * ((a * i) - (z * c));
	double t_2 = x * (y * z);
	double tmp;
	if (z <= -1.6e+267) {
		tmp = t_2;
	} else if (z <= -4.4e+210) {
		tmp = t_1;
	} else if (z <= -2e+158) {
		tmp = y * (x * z);
	} else if (z <= -3.2e+38) {
		tmp = t_1;
	} else if (z <= 5.8e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 8.2e+107) {
		tmp = j * -(y * i);
	} else if (z <= 7e+248) {
		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 = b * ((a * i) - (z * c))
    t_2 = x * (y * z)
    if (z <= (-1.6d+267)) then
        tmp = t_2
    else if (z <= (-4.4d+210)) then
        tmp = t_1
    else if (z <= (-2d+158)) then
        tmp = y * (x * z)
    else if (z <= (-3.2d+38)) then
        tmp = t_1
    else if (z <= 5.8d-78) then
        tmp = a * ((b * i) - (x * t))
    else if (z <= 8.2d+107) then
        tmp = j * -(y * i)
    else if (z <= 7d+248) 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 = b * ((a * i) - (z * c));
	double t_2 = x * (y * z);
	double tmp;
	if (z <= -1.6e+267) {
		tmp = t_2;
	} else if (z <= -4.4e+210) {
		tmp = t_1;
	} else if (z <= -2e+158) {
		tmp = y * (x * z);
	} else if (z <= -3.2e+38) {
		tmp = t_1;
	} else if (z <= 5.8e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 8.2e+107) {
		tmp = j * -(y * i);
	} else if (z <= 7e+248) {
		tmp = t_1;
	} 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 = x * (y * z)
	tmp = 0
	if z <= -1.6e+267:
		tmp = t_2
	elif z <= -4.4e+210:
		tmp = t_1
	elif z <= -2e+158:
		tmp = y * (x * z)
	elif z <= -3.2e+38:
		tmp = t_1
	elif z <= 5.8e-78:
		tmp = a * ((b * i) - (x * t))
	elif z <= 8.2e+107:
		tmp = j * -(y * i)
	elif z <= 7e+248:
		tmp = t_1
	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(x * Float64(y * z))
	tmp = 0.0
	if (z <= -1.6e+267)
		tmp = t_2;
	elseif (z <= -4.4e+210)
		tmp = t_1;
	elseif (z <= -2e+158)
		tmp = Float64(y * Float64(x * z));
	elseif (z <= -3.2e+38)
		tmp = t_1;
	elseif (z <= 5.8e-78)
		tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t)));
	elseif (z <= 8.2e+107)
		tmp = Float64(j * Float64(-Float64(y * i)));
	elseif (z <= 7e+248)
		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 = b * ((a * i) - (z * c));
	t_2 = x * (y * z);
	tmp = 0.0;
	if (z <= -1.6e+267)
		tmp = t_2;
	elseif (z <= -4.4e+210)
		tmp = t_1;
	elseif (z <= -2e+158)
		tmp = y * (x * z);
	elseif (z <= -3.2e+38)
		tmp = t_1;
	elseif (z <= 5.8e-78)
		tmp = a * ((b * i) - (x * t));
	elseif (z <= 8.2e+107)
		tmp = j * -(y * i);
	elseif (z <= 7e+248)
		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[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.6e+267], t$95$2, If[LessEqual[z, -4.4e+210], t$95$1, If[LessEqual[z, -2e+158], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.2e+38], t$95$1, If[LessEqual[z, 5.8e-78], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.2e+107], N[(j * (-N[(y * i), $MachinePrecision])), $MachinePrecision], If[LessEqual[z, 7e+248], t$95$1, t$95$2]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 50.6% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\ t_2 := z \cdot \left(x \cdot y - b \cdot c\right)\\ t_3 := j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{if}\;z \leq -2.5 \cdot 10^{+59}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq -3 \cdot 10^{-62}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{-140}:\\ \;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\ \mathbf{elif}\;z \leq -3.8 \cdot 10^{-250}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 4.7 \cdot 10^{-293}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq 3 \cdot 10^{-78}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 1.1 \cdot 10^{-13}:\\ \;\;\;\;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 (* a (- (* b i) (* x t))))
        (t_2 (* z (- (* x y) (* b c))))
        (t_3 (* j (- (* t c) (* y i)))))
   (if (<= z -2.5e+59)
     t_2
     (if (<= z -3e-62)
       t_1
       (if (<= z -1.05e-140)
         (* y (- (* x z) (* i j)))
         (if (<= z -3.8e-250)
           t_1
           (if (<= z 4.7e-293)
             t_3
             (if (<= z 3e-78) t_1 (if (<= z 1.1e-13) 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 = a * ((b * i) - (x * t));
	double t_2 = z * ((x * y) - (b * c));
	double t_3 = j * ((t * c) - (y * i));
	double tmp;
	if (z <= -2.5e+59) {
		tmp = t_2;
	} else if (z <= -3e-62) {
		tmp = t_1;
	} else if (z <= -1.05e-140) {
		tmp = y * ((x * z) - (i * j));
	} else if (z <= -3.8e-250) {
		tmp = t_1;
	} else if (z <= 4.7e-293) {
		tmp = t_3;
	} else if (z <= 3e-78) {
		tmp = t_1;
	} else if (z <= 1.1e-13) {
		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 = a * ((b * i) - (x * t))
    t_2 = z * ((x * y) - (b * c))
    t_3 = j * ((t * c) - (y * i))
    if (z <= (-2.5d+59)) then
        tmp = t_2
    else if (z <= (-3d-62)) then
        tmp = t_1
    else if (z <= (-1.05d-140)) then
        tmp = y * ((x * z) - (i * j))
    else if (z <= (-3.8d-250)) then
        tmp = t_1
    else if (z <= 4.7d-293) then
        tmp = t_3
    else if (z <= 3d-78) then
        tmp = t_1
    else if (z <= 1.1d-13) 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 = a * ((b * i) - (x * t));
	double t_2 = z * ((x * y) - (b * c));
	double t_3 = j * ((t * c) - (y * i));
	double tmp;
	if (z <= -2.5e+59) {
		tmp = t_2;
	} else if (z <= -3e-62) {
		tmp = t_1;
	} else if (z <= -1.05e-140) {
		tmp = y * ((x * z) - (i * j));
	} else if (z <= -3.8e-250) {
		tmp = t_1;
	} else if (z <= 4.7e-293) {
		tmp = t_3;
	} else if (z <= 3e-78) {
		tmp = t_1;
	} else if (z <= 1.1e-13) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = a * ((b * i) - (x * t))
	t_2 = z * ((x * y) - (b * c))
	t_3 = j * ((t * c) - (y * i))
	tmp = 0
	if z <= -2.5e+59:
		tmp = t_2
	elif z <= -3e-62:
		tmp = t_1
	elif z <= -1.05e-140:
		tmp = y * ((x * z) - (i * j))
	elif z <= -3.8e-250:
		tmp = t_1
	elif z <= 4.7e-293:
		tmp = t_3
	elif z <= 3e-78:
		tmp = t_1
	elif z <= 1.1e-13:
		tmp = t_3
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t)))
	t_2 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	t_3 = Float64(j * Float64(Float64(t * c) - Float64(y * i)))
	tmp = 0.0
	if (z <= -2.5e+59)
		tmp = t_2;
	elseif (z <= -3e-62)
		tmp = t_1;
	elseif (z <= -1.05e-140)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j)));
	elseif (z <= -3.8e-250)
		tmp = t_1;
	elseif (z <= 4.7e-293)
		tmp = t_3;
	elseif (z <= 3e-78)
		tmp = t_1;
	elseif (z <= 1.1e-13)
		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 = a * ((b * i) - (x * t));
	t_2 = z * ((x * y) - (b * c));
	t_3 = j * ((t * c) - (y * i));
	tmp = 0.0;
	if (z <= -2.5e+59)
		tmp = t_2;
	elseif (z <= -3e-62)
		tmp = t_1;
	elseif (z <= -1.05e-140)
		tmp = y * ((x * z) - (i * j));
	elseif (z <= -3.8e-250)
		tmp = t_1;
	elseif (z <= 4.7e-293)
		tmp = t_3;
	elseif (z <= 3e-78)
		tmp = t_1;
	elseif (z <= 1.1e-13)
		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[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.5e+59], t$95$2, If[LessEqual[z, -3e-62], t$95$1, If[LessEqual[z, -1.05e-140], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.8e-250], t$95$1, If[LessEqual[z, 4.7e-293], t$95$3, If[LessEqual[z, 3e-78], t$95$1, If[LessEqual[z, 1.1e-13], t$95$3, t$95$2]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 52.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\ t_2 := x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ t_3 := z \cdot \left(x \cdot y - b \cdot c\right)\\ \mathbf{if}\;z \leq -5.8 \cdot 10^{+53}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;z \leq -1.1 \cdot 10^{-229}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq 1.3 \cdot 10^{-305}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{-293}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq 7.9 \cdot 10^{-78}:\\ \;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;z \leq 1.22 \cdot 10^{-11}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \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 (+ (* x (- (* y z) (* t a))) (* c (* t j))))
        (t_3 (* z (- (* x y) (* b c)))))
   (if (<= z -5.8e+53)
     t_3
     (if (<= z -1.1e-229)
       t_2
       (if (<= z 1.3e-305)
         t_1
         (if (<= z 2.1e-293)
           t_2
           (if (<= z 7.9e-78)
             (* a (- (* b i) (* x t)))
             (if (<= z 1.22e-11) t_1 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 = j * ((t * c) - (y * i));
	double t_2 = (x * ((y * z) - (t * a))) + (c * (t * j));
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -5.8e+53) {
		tmp = t_3;
	} else if (z <= -1.1e-229) {
		tmp = t_2;
	} else if (z <= 1.3e-305) {
		tmp = t_1;
	} else if (z <= 2.1e-293) {
		tmp = t_2;
	} else if (z <= 7.9e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 1.22e-11) {
		tmp = t_1;
	} 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 = j * ((t * c) - (y * i))
    t_2 = (x * ((y * z) - (t * a))) + (c * (t * j))
    t_3 = z * ((x * y) - (b * c))
    if (z <= (-5.8d+53)) then
        tmp = t_3
    else if (z <= (-1.1d-229)) then
        tmp = t_2
    else if (z <= 1.3d-305) then
        tmp = t_1
    else if (z <= 2.1d-293) then
        tmp = t_2
    else if (z <= 7.9d-78) then
        tmp = a * ((b * i) - (x * t))
    else if (z <= 1.22d-11) then
        tmp = t_1
    else
        tmp = t_3
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((t * c) - (y * i));
	double t_2 = (x * ((y * z) - (t * a))) + (c * (t * j));
	double t_3 = z * ((x * y) - (b * c));
	double tmp;
	if (z <= -5.8e+53) {
		tmp = t_3;
	} else if (z <= -1.1e-229) {
		tmp = t_2;
	} else if (z <= 1.3e-305) {
		tmp = t_1;
	} else if (z <= 2.1e-293) {
		tmp = t_2;
	} else if (z <= 7.9e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 1.22e-11) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((t * c) - (y * i))
	t_2 = (x * ((y * z) - (t * a))) + (c * (t * j))
	t_3 = z * ((x * y) - (b * c))
	tmp = 0
	if z <= -5.8e+53:
		tmp = t_3
	elif z <= -1.1e-229:
		tmp = t_2
	elif z <= 1.3e-305:
		tmp = t_1
	elif z <= 2.1e-293:
		tmp = t_2
	elif z <= 7.9e-78:
		tmp = a * ((b * i) - (x * t))
	elif z <= 1.22e-11:
		tmp = t_1
	else:
		tmp = t_3
	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(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(c * Float64(t * j)))
	t_3 = Float64(z * Float64(Float64(x * y) - Float64(b * c)))
	tmp = 0.0
	if (z <= -5.8e+53)
		tmp = t_3;
	elseif (z <= -1.1e-229)
		tmp = t_2;
	elseif (z <= 1.3e-305)
		tmp = t_1;
	elseif (z <= 2.1e-293)
		tmp = t_2;
	elseif (z <= 7.9e-78)
		tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t)));
	elseif (z <= 1.22e-11)
		tmp = t_1;
	else
		tmp = t_3;
	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 = (x * ((y * z) - (t * a))) + (c * (t * j));
	t_3 = z * ((x * y) - (b * c));
	tmp = 0.0;
	if (z <= -5.8e+53)
		tmp = t_3;
	elseif (z <= -1.1e-229)
		tmp = t_2;
	elseif (z <= 1.3e-305)
		tmp = t_1;
	elseif (z <= 2.1e-293)
		tmp = t_2;
	elseif (z <= 7.9e-78)
		tmp = a * ((b * i) - (x * t));
	elseif (z <= 1.22e-11)
		tmp = t_1;
	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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.8e+53], t$95$3, If[LessEqual[z, -1.1e-229], t$95$2, If[LessEqual[z, 1.3e-305], t$95$1, If[LessEqual[z, 2.1e-293], t$95$2, If[LessEqual[z, 7.9e-78], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.22e-11], t$95$1, t$95$3]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 60.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\ t_2 := x \cdot \left(y \cdot z - t \cdot a\right) + c \cdot \left(t \cdot j\right)\\ \mathbf{if}\;b \leq -4.4 \cdot 10^{+17}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -3.2 \cdot 10^{-125}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq -2.4 \cdot 10^{-161}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{elif}\;b \leq 5.4 \cdot 10^{-105}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (+ (* x (* y z)) (* b (- (* a i) (* z c)))))
        (t_2 (+ (* x (- (* y z) (* t a))) (* c (* t j)))))
   (if (<= b -4.4e+17)
     t_1
     (if (<= b -3.2e-125)
       t_2
       (if (<= b -2.4e-161)
         (* j (- (* t c) (* y i)))
         (if (<= b 5.4e-105) t_2 t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)));
	double t_2 = (x * ((y * z) - (t * a))) + (c * (t * j));
	double tmp;
	if (b <= -4.4e+17) {
		tmp = t_1;
	} else if (b <= -3.2e-125) {
		tmp = t_2;
	} else if (b <= -2.4e-161) {
		tmp = j * ((t * c) - (y * i));
	} else if (b <= 5.4e-105) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: tmp
    t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)))
    t_2 = (x * ((y * z) - (t * a))) + (c * (t * j))
    if (b <= (-4.4d+17)) then
        tmp = t_1
    else if (b <= (-3.2d-125)) then
        tmp = t_2
    else if (b <= (-2.4d-161)) then
        tmp = j * ((t * c) - (y * i))
    else if (b <= 5.4d-105) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)));
	double t_2 = (x * ((y * z) - (t * a))) + (c * (t * j));
	double tmp;
	if (b <= -4.4e+17) {
		tmp = t_1;
	} else if (b <= -3.2e-125) {
		tmp = t_2;
	} else if (b <= -2.4e-161) {
		tmp = j * ((t * c) - (y * i));
	} else if (b <= 5.4e-105) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)))
	t_2 = (x * ((y * z) - (t * a))) + (c * (t * j))
	tmp = 0
	if b <= -4.4e+17:
		tmp = t_1
	elif b <= -3.2e-125:
		tmp = t_2
	elif b <= -2.4e-161:
		tmp = j * ((t * c) - (y * i))
	elif b <= 5.4e-105:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c))))
	t_2 = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(c * Float64(t * j)))
	tmp = 0.0
	if (b <= -4.4e+17)
		tmp = t_1;
	elseif (b <= -3.2e-125)
		tmp = t_2;
	elseif (b <= -2.4e-161)
		tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i)));
	elseif (b <= 5.4e-105)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)));
	t_2 = (x * ((y * z) - (t * a))) + (c * (t * j));
	tmp = 0.0;
	if (b <= -4.4e+17)
		tmp = t_1;
	elseif (b <= -3.2e-125)
		tmp = t_2;
	elseif (b <= -2.4e-161)
		tmp = j * ((t * c) - (y * i));
	elseif (b <= 5.4e-105)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.4e+17], t$95$1, If[LessEqual[b, -3.2e-125], t$95$2, If[LessEqual[b, -2.4e-161], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.4e-105], t$95$2, t$95$1]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 50.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\ t_2 := c \cdot \left(t \cdot j - z \cdot b\right)\\ \mathbf{if}\;c \leq -3.4 \cdot 10^{+85}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;c \leq -3.1 \cdot 10^{-180}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;c \leq -1.34 \cdot 10^{-225}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;c \leq 5 \cdot 10^{-89} \lor \neg \left(c \leq 2.25 \cdot 10^{-12}\right) \land c \leq 2 \cdot 10^{+96}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* a (- (* b i) (* x t)))) (t_2 (* c (- (* t j) (* z b)))))
   (if (<= c -3.4e+85)
     t_2
     (if (<= c -3.1e-180)
       t_1
       (if (<= c -1.34e-225)
         (* z (* x y))
         (if (or (<= c 5e-89) (and (not (<= c 2.25e-12)) (<= c 2e+96)))
           t_1
           t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = a * ((b * i) - (x * t));
	double t_2 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -3.4e+85) {
		tmp = t_2;
	} else if (c <= -3.1e-180) {
		tmp = t_1;
	} else if (c <= -1.34e-225) {
		tmp = z * (x * y);
	} else if ((c <= 5e-89) || (!(c <= 2.25e-12) && (c <= 2e+96))) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = a * ((b * i) - (x * t))
    t_2 = c * ((t * j) - (z * b))
    if (c <= (-3.4d+85)) then
        tmp = t_2
    else if (c <= (-3.1d-180)) then
        tmp = t_1
    else if (c <= (-1.34d-225)) then
        tmp = z * (x * y)
    else if ((c <= 5d-89) .or. (.not. (c <= 2.25d-12)) .and. (c <= 2d+96)) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = a * ((b * i) - (x * t));
	double t_2 = c * ((t * j) - (z * b));
	double tmp;
	if (c <= -3.4e+85) {
		tmp = t_2;
	} else if (c <= -3.1e-180) {
		tmp = t_1;
	} else if (c <= -1.34e-225) {
		tmp = z * (x * y);
	} else if ((c <= 5e-89) || (!(c <= 2.25e-12) && (c <= 2e+96))) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = a * ((b * i) - (x * t))
	t_2 = c * ((t * j) - (z * b))
	tmp = 0
	if c <= -3.4e+85:
		tmp = t_2
	elif c <= -3.1e-180:
		tmp = t_1
	elif c <= -1.34e-225:
		tmp = z * (x * y)
	elif (c <= 5e-89) or (not (c <= 2.25e-12) and (c <= 2e+96)):
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t)))
	t_2 = Float64(c * Float64(Float64(t * j) - Float64(z * b)))
	tmp = 0.0
	if (c <= -3.4e+85)
		tmp = t_2;
	elseif (c <= -3.1e-180)
		tmp = t_1;
	elseif (c <= -1.34e-225)
		tmp = Float64(z * Float64(x * y));
	elseif ((c <= 5e-89) || (!(c <= 2.25e-12) && (c <= 2e+96)))
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = a * ((b * i) - (x * t));
	t_2 = c * ((t * j) - (z * b));
	tmp = 0.0;
	if (c <= -3.4e+85)
		tmp = t_2;
	elseif (c <= -3.1e-180)
		tmp = t_1;
	elseif (c <= -1.34e-225)
		tmp = z * (x * y);
	elseif ((c <= 5e-89) || (~((c <= 2.25e-12)) && (c <= 2e+96)))
		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[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.4e+85], t$95$2, If[LessEqual[c, -3.1e-180], t$95$1, If[LessEqual[c, -1.34e-225], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[c, 5e-89], And[N[Not[LessEqual[c, 2.25e-12]], $MachinePrecision], LessEqual[c, 2e+96]]], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 39.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := c \cdot \left(z \cdot \left(-b\right)\right)\\ t_2 := x \cdot \left(y \cdot z\right)\\ \mathbf{if}\;z \leq -5.5 \cdot 10^{+233}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;z \leq -8 \cdot 10^{+210}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -1.75 \cdot 10^{+162}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{elif}\;z \leq -1.85 \cdot 10^{+62}:\\ \;\;\;\;b \cdot \left(z \cdot \left(-c\right)\right)\\ \mathbf{elif}\;z \leq 8.5 \cdot 10^{-78}:\\ \;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\ \mathbf{elif}\;z \leq 1.2 \cdot 10^{+141}:\\ \;\;\;\;j \cdot \left(-y \cdot i\right)\\ \mathbf{elif}\;z \leq 10^{+249}:\\ \;\;\;\;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 (* c (* z (- b)))) (t_2 (* x (* y z))))
   (if (<= z -5.5e+233)
     t_2
     (if (<= z -8e+210)
       t_1
       (if (<= z -1.75e+162)
         (* y (* x z))
         (if (<= z -1.85e+62)
           (* b (* z (- c)))
           (if (<= z 8.5e-78)
             (* a (- (* b i) (* x t)))
             (if (<= z 1.2e+141)
               (* j (- (* y i)))
               (if (<= z 1e+249) 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 = c * (z * -b);
	double t_2 = x * (y * z);
	double tmp;
	if (z <= -5.5e+233) {
		tmp = t_2;
	} else if (z <= -8e+210) {
		tmp = t_1;
	} else if (z <= -1.75e+162) {
		tmp = y * (x * z);
	} else if (z <= -1.85e+62) {
		tmp = b * (z * -c);
	} else if (z <= 8.5e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 1.2e+141) {
		tmp = j * -(y * i);
	} else if (z <= 1e+249) {
		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 = c * (z * -b)
    t_2 = x * (y * z)
    if (z <= (-5.5d+233)) then
        tmp = t_2
    else if (z <= (-8d+210)) then
        tmp = t_1
    else if (z <= (-1.75d+162)) then
        tmp = y * (x * z)
    else if (z <= (-1.85d+62)) then
        tmp = b * (z * -c)
    else if (z <= 8.5d-78) then
        tmp = a * ((b * i) - (x * t))
    else if (z <= 1.2d+141) then
        tmp = j * -(y * i)
    else if (z <= 1d+249) 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 = c * (z * -b);
	double t_2 = x * (y * z);
	double tmp;
	if (z <= -5.5e+233) {
		tmp = t_2;
	} else if (z <= -8e+210) {
		tmp = t_1;
	} else if (z <= -1.75e+162) {
		tmp = y * (x * z);
	} else if (z <= -1.85e+62) {
		tmp = b * (z * -c);
	} else if (z <= 8.5e-78) {
		tmp = a * ((b * i) - (x * t));
	} else if (z <= 1.2e+141) {
		tmp = j * -(y * i);
	} else if (z <= 1e+249) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * (z * -b)
	t_2 = x * (y * z)
	tmp = 0
	if z <= -5.5e+233:
		tmp = t_2
	elif z <= -8e+210:
		tmp = t_1
	elif z <= -1.75e+162:
		tmp = y * (x * z)
	elif z <= -1.85e+62:
		tmp = b * (z * -c)
	elif z <= 8.5e-78:
		tmp = a * ((b * i) - (x * t))
	elif z <= 1.2e+141:
		tmp = j * -(y * i)
	elif z <= 1e+249:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(z * Float64(-b)))
	t_2 = Float64(x * Float64(y * z))
	tmp = 0.0
	if (z <= -5.5e+233)
		tmp = t_2;
	elseif (z <= -8e+210)
		tmp = t_1;
	elseif (z <= -1.75e+162)
		tmp = Float64(y * Float64(x * z));
	elseif (z <= -1.85e+62)
		tmp = Float64(b * Float64(z * Float64(-c)));
	elseif (z <= 8.5e-78)
		tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t)));
	elseif (z <= 1.2e+141)
		tmp = Float64(j * Float64(-Float64(y * i)));
	elseif (z <= 1e+249)
		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 = c * (z * -b);
	t_2 = x * (y * z);
	tmp = 0.0;
	if (z <= -5.5e+233)
		tmp = t_2;
	elseif (z <= -8e+210)
		tmp = t_1;
	elseif (z <= -1.75e+162)
		tmp = y * (x * z);
	elseif (z <= -1.85e+62)
		tmp = b * (z * -c);
	elseif (z <= 8.5e-78)
		tmp = a * ((b * i) - (x * t));
	elseif (z <= 1.2e+141)
		tmp = j * -(y * i);
	elseif (z <= 1e+249)
		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[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.5e+233], t$95$2, If[LessEqual[z, -8e+210], t$95$1, If[LessEqual[z, -1.75e+162], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.85e+62], N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e-78], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e+141], N[(j * (-N[(y * i), $MachinePrecision])), $MachinePrecision], If[LessEqual[z, 1e+249], t$95$1, t$95$2]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 51.8% 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 -9.5 \cdot 10^{-10}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.2 \cdot 10^{-228}:\\ \;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\ \mathbf{elif}\;b \leq 6 \cdot 10^{-131}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\ \mathbf{elif}\;b \leq 4.2 \cdot 10^{-80}:\\ \;\;\;\;y \cdot \left(x \cdot z - i \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 -9.5e-10)
     t_1
     (if (<= b 1.2e-228)
       (* x (- (* y z) (* t a)))
       (if (<= b 6e-131)
         (* j (- (* t c) (* y i)))
         (if (<= b 4.2e-80) (* y (- (* x z) (* i 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 <= -9.5e-10) {
		tmp = t_1;
	} else if (b <= 1.2e-228) {
		tmp = x * ((y * z) - (t * a));
	} else if (b <= 6e-131) {
		tmp = j * ((t * c) - (y * i));
	} else if (b <= 4.2e-80) {
		tmp = y * ((x * z) - (i * 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 <= (-9.5d-10)) then
        tmp = t_1
    else if (b <= 1.2d-228) then
        tmp = x * ((y * z) - (t * a))
    else if (b <= 6d-131) then
        tmp = j * ((t * c) - (y * i))
    else if (b <= 4.2d-80) then
        tmp = y * ((x * z) - (i * 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 <= -9.5e-10) {
		tmp = t_1;
	} else if (b <= 1.2e-228) {
		tmp = x * ((y * z) - (t * a));
	} else if (b <= 6e-131) {
		tmp = j * ((t * c) - (y * i));
	} else if (b <= 4.2e-80) {
		tmp = y * ((x * z) - (i * 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 <= -9.5e-10:
		tmp = t_1
	elif b <= 1.2e-228:
		tmp = x * ((y * z) - (t * a))
	elif b <= 6e-131:
		tmp = j * ((t * c) - (y * i))
	elif b <= 4.2e-80:
		tmp = y * ((x * z) - (i * 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 <= -9.5e-10)
		tmp = t_1;
	elseif (b <= 1.2e-228)
		tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a)));
	elseif (b <= 6e-131)
		tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i)));
	elseif (b <= 4.2e-80)
		tmp = Float64(y * Float64(Float64(x * z) - Float64(i * 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 <= -9.5e-10)
		tmp = t_1;
	elseif (b <= 1.2e-228)
		tmp = x * ((y * z) - (t * a));
	elseif (b <= 6e-131)
		tmp = j * ((t * c) - (y * i));
	elseif (b <= 4.2e-80)
		tmp = y * ((x * z) - (i * 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, -9.5e-10], t$95$1, If[LessEqual[b, 1.2e-228], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6e-131], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.2e-80], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 51.1% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(x \cdot z - i \cdot j\right)\\ t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\ \mathbf{if}\;b \leq -6.4 \cdot 10^{+81}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;b \leq 1.1 \cdot 10^{-263}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 1.65 \cdot 10^{-151}:\\ \;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\ \mathbf{elif}\;b \leq 4.4 \cdot 10^{-80}:\\ \;\;\;\;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 (* y (- (* x z) (* i j)))) (t_2 (* b (- (* a i) (* z c)))))
   (if (<= b -6.4e+81)
     t_2
     (if (<= b 1.1e-263)
       t_1
       (if (<= b 1.65e-151)
         (* t (- (* c j) (* x a)))
         (if (<= b 4.4e-80) 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 = y * ((x * z) - (i * j));
	double t_2 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -6.4e+81) {
		tmp = t_2;
	} else if (b <= 1.1e-263) {
		tmp = t_1;
	} else if (b <= 1.65e-151) {
		tmp = t * ((c * j) - (x * a));
	} else if (b <= 4.4e-80) {
		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 = y * ((x * z) - (i * j))
    t_2 = b * ((a * i) - (z * c))
    if (b <= (-6.4d+81)) then
        tmp = t_2
    else if (b <= 1.1d-263) then
        tmp = t_1
    else if (b <= 1.65d-151) then
        tmp = t * ((c * j) - (x * a))
    else if (b <= 4.4d-80) 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 = y * ((x * z) - (i * j));
	double t_2 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -6.4e+81) {
		tmp = t_2;
	} else if (b <= 1.1e-263) {
		tmp = t_1;
	} else if (b <= 1.65e-151) {
		tmp = t * ((c * j) - (x * a));
	} else if (b <= 4.4e-80) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = y * ((x * z) - (i * j))
	t_2 = b * ((a * i) - (z * c))
	tmp = 0
	if b <= -6.4e+81:
		tmp = t_2
	elif b <= 1.1e-263:
		tmp = t_1
	elif b <= 1.65e-151:
		tmp = t * ((c * j) - (x * a))
	elif b <= 4.4e-80:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(y * Float64(Float64(x * z) - Float64(i * j)))
	t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c)))
	tmp = 0.0
	if (b <= -6.4e+81)
		tmp = t_2;
	elseif (b <= 1.1e-263)
		tmp = t_1;
	elseif (b <= 1.65e-151)
		tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a)));
	elseif (b <= 4.4e-80)
		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 = y * ((x * z) - (i * j));
	t_2 = b * ((a * i) - (z * c));
	tmp = 0.0;
	if (b <= -6.4e+81)
		tmp = t_2;
	elseif (b <= 1.1e-263)
		tmp = t_1;
	elseif (b <= 1.65e-151)
		tmp = t * ((c * j) - (x * a));
	elseif (b <= 4.4e-80)
		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[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.4e+81], t$95$2, If[LessEqual[b, 1.1e-263], t$95$1, If[LessEqual[b, 1.65e-151], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.4e-80], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 46.9% accurate, 1.9× 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.4 \cdot 10^{-26}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq -2 \cdot 10^{-276}:\\ \;\;\;\;z \cdot \left(x \cdot y\right)\\ \mathbf{elif}\;b \leq 8.6 \cdot 10^{-94}:\\ \;\;\;\;j \cdot \left(t \cdot c - y \cdot i\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.4e-26)
     t_1
     (if (<= b -2e-276)
       (* z (* x y))
       (if (<= b 8.6e-94) (* j (- (* t c) (* y i))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -7.4e-26) {
		tmp = t_1;
	} else if (b <= -2e-276) {
		tmp = z * (x * y);
	} else if (b <= 8.6e-94) {
		tmp = j * ((t * c) - (y * i));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = b * ((a * i) - (z * c))
    if (b <= (-7.4d-26)) then
        tmp = t_1
    else if (b <= (-2d-276)) then
        tmp = z * (x * y)
    else if (b <= 8.6d-94) then
        tmp = j * ((t * c) - (y * i))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = b * ((a * i) - (z * c));
	double tmp;
	if (b <= -7.4e-26) {
		tmp = t_1;
	} else if (b <= -2e-276) {
		tmp = z * (x * y);
	} else if (b <= 8.6e-94) {
		tmp = j * ((t * c) - (y * i));
	} 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.4e-26:
		tmp = t_1
	elif b <= -2e-276:
		tmp = z * (x * y)
	elif b <= 8.6e-94:
		tmp = j * ((t * c) - (y * i))
	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.4e-26)
		tmp = t_1;
	elseif (b <= -2e-276)
		tmp = Float64(z * Float64(x * y));
	elseif (b <= 8.6e-94)
		tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = b * ((a * i) - (z * c));
	tmp = 0.0;
	if (b <= -7.4e-26)
		tmp = t_1;
	elseif (b <= -2e-276)
		tmp = z * (x * y);
	elseif (b <= 8.6e-94)
		tmp = j * ((t * c) - (y * i));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 29.0% accurate, 2.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(y \cdot z\right)\\ \mathbf{if}\;b \leq -9.5 \cdot 10^{+98}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;b \leq 3.1 \cdot 10^{-228}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;b \leq 4.4 \cdot 10^{-131}:\\ \;\;\;\;j \cdot \left(t \cdot c\right)\\ \mathbf{elif}\;b \leq 9.2 \cdot 10^{+123}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* x (* y z))))
   (if (<= b -9.5e+98)
     (* a (* b i))
     (if (<= b 3.1e-228)
       t_1
       (if (<= b 4.4e-131)
         (* j (* t c))
         (if (<= b 9.2e+123) t_1 (* b (* a i))))))))

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 tmp;
	if (b <= -9.5e+98) {
		tmp = a * (b * i);
	} else if (b <= 3.1e-228) {
		tmp = t_1;
	} else if (b <= 4.4e-131) {
		tmp = j * (t * c);
	} else if (b <= 9.2e+123) {
		tmp = t_1;
	} else {
		tmp = b * (a * 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) :: t_1
    real(8) :: tmp
    t_1 = x * (y * z)
    if (b <= (-9.5d+98)) then
        tmp = a * (b * i)
    else if (b <= 3.1d-228) then
        tmp = t_1
    else if (b <= 4.4d-131) then
        tmp = j * (t * c)
    else if (b <= 9.2d+123) then
        tmp = t_1
    else
        tmp = b * (a * 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 t_1 = x * (y * z);
	double tmp;
	if (b <= -9.5e+98) {
		tmp = a * (b * i);
	} else if (b <= 3.1e-228) {
		tmp = t_1;
	} else if (b <= 4.4e-131) {
		tmp = j * (t * c);
	} else if (b <= 9.2e+123) {
		tmp = t_1;
	} else {
		tmp = b * (a * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = x * (y * z)
	tmp = 0
	if b <= -9.5e+98:
		tmp = a * (b * i)
	elif b <= 3.1e-228:
		tmp = t_1
	elif b <= 4.4e-131:
		tmp = j * (t * c)
	elif b <= 9.2e+123:
		tmp = t_1
	else:
		tmp = b * (a * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(x * Float64(y * z))
	tmp = 0.0
	if (b <= -9.5e+98)
		tmp = Float64(a * Float64(b * i));
	elseif (b <= 3.1e-228)
		tmp = t_1;
	elseif (b <= 4.4e-131)
		tmp = Float64(j * Float64(t * c));
	elseif (b <= 9.2e+123)
		tmp = t_1;
	else
		tmp = Float64(b * Float64(a * i));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = x * (y * z);
	tmp = 0.0;
	if (b <= -9.5e+98)
		tmp = a * (b * i);
	elseif (b <= 3.1e-228)
		tmp = t_1;
	elseif (b <= 4.4e-131)
		tmp = j * (t * c);
	elseif (b <= 9.2e+123)
		tmp = t_1;
	else
		tmp = b * (a * i);
	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]}, If[LessEqual[b, -9.5e+98], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.1e-228], t$95$1, If[LessEqual[b, 4.4e-131], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.2e+123], t$95$1, N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 28.9% accurate, 2.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -1.1 \cdot 10^{+99}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{elif}\;b \leq 2.6 \cdot 10^{-229}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{-131}:\\ \;\;\;\;j \cdot \left(t \cdot c\right)\\ \mathbf{elif}\;b \leq 4 \cdot 10^{+125}:\\ \;\;\;\;y \cdot \left(x \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (if (<= b -1.1e+99)
   (* a (* b i))
   (if (<= b 2.6e-229)
     (* x (* y z))
     (if (<= b 4.8e-131)
       (* j (* t c))
       (if (<= b 4e+125) (* y (* x z)) (* b (* a 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 (b <= -1.1e+99) {
		tmp = a * (b * i);
	} else if (b <= 2.6e-229) {
		tmp = x * (y * z);
	} else if (b <= 4.8e-131) {
		tmp = j * (t * c);
	} else if (b <= 4e+125) {
		tmp = y * (x * z);
	} else {
		tmp = b * (a * 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 (b <= (-1.1d+99)) then
        tmp = a * (b * i)
    else if (b <= 2.6d-229) then
        tmp = x * (y * z)
    else if (b <= 4.8d-131) then
        tmp = j * (t * c)
    else if (b <= 4d+125) then
        tmp = y * (x * z)
    else
        tmp = b * (a * 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 (b <= -1.1e+99) {
		tmp = a * (b * i);
	} else if (b <= 2.6e-229) {
		tmp = x * (y * z);
	} else if (b <= 4.8e-131) {
		tmp = j * (t * c);
	} else if (b <= 4e+125) {
		tmp = y * (x * z);
	} else {
		tmp = b * (a * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if b <= -1.1e+99:
		tmp = a * (b * i)
	elif b <= 2.6e-229:
		tmp = x * (y * z)
	elif b <= 4.8e-131:
		tmp = j * (t * c)
	elif b <= 4e+125:
		tmp = y * (x * z)
	else:
		tmp = b * (a * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (b <= -1.1e+99)
		tmp = Float64(a * Float64(b * i));
	elseif (b <= 2.6e-229)
		tmp = Float64(x * Float64(y * z));
	elseif (b <= 4.8e-131)
		tmp = Float64(j * Float64(t * c));
	elseif (b <= 4e+125)
		tmp = Float64(y * Float64(x * z));
	else
		tmp = Float64(b * Float64(a * i));
	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+99)
		tmp = a * (b * i);
	elseif (b <= 2.6e-229)
		tmp = x * (y * z);
	elseif (b <= 4.8e-131)
		tmp = j * (t * c);
	elseif (b <= 4e+125)
		tmp = y * (x * z);
	else
		tmp = b * (a * i);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -1.1e+99], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.6e-229], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.8e-131], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4e+125], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 19: 30.5% accurate, 2.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -5.5 \cdot 10^{+31}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;a \leq -8.5 \cdot 10^{-139}:\\ \;\;\;\;c \cdot \left(z \cdot \left(-b\right)\right)\\ \mathbf{elif}\;a \leq -1.5 \cdot 10^{-201}:\\ \;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\ \mathbf{elif}\;a \leq 1.25 \cdot 10^{+39}:\\ \;\;\;\;x \cdot \left(y \cdot z\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 (<= a -5.5e+31)
   (* b (* a i))
   (if (<= a -8.5e-139)
     (* c (* z (- b)))
     (if (<= a -1.5e-201)
       (* i (* y (- j)))
       (if (<= a 1.25e+39) (* x (* y z)) (* 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 (a <= -5.5e+31) {
		tmp = b * (a * i);
	} else if (a <= -8.5e-139) {
		tmp = c * (z * -b);
	} else if (a <= -1.5e-201) {
		tmp = i * (y * -j);
	} else if (a <= 1.25e+39) {
		tmp = x * (y * z);
	} 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 (a <= (-5.5d+31)) then
        tmp = b * (a * i)
    else if (a <= (-8.5d-139)) then
        tmp = c * (z * -b)
    else if (a <= (-1.5d-201)) then
        tmp = i * (y * -j)
    else if (a <= 1.25d+39) then
        tmp = x * (y * z)
    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 (a <= -5.5e+31) {
		tmp = b * (a * i);
	} else if (a <= -8.5e-139) {
		tmp = c * (z * -b);
	} else if (a <= -1.5e-201) {
		tmp = i * (y * -j);
	} else if (a <= 1.25e+39) {
		tmp = x * (y * z);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if a <= -5.5e+31:
		tmp = b * (a * i)
	elif a <= -8.5e-139:
		tmp = c * (z * -b)
	elif a <= -1.5e-201:
		tmp = i * (y * -j)
	elif a <= 1.25e+39:
		tmp = x * (y * z)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (a <= -5.5e+31)
		tmp = Float64(b * Float64(a * i));
	elseif (a <= -8.5e-139)
		tmp = Float64(c * Float64(z * Float64(-b)));
	elseif (a <= -1.5e-201)
		tmp = Float64(i * Float64(y * Float64(-j)));
	elseif (a <= 1.25e+39)
		tmp = Float64(x * Float64(y * z));
	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 (a <= -5.5e+31)
		tmp = b * (a * i);
	elseif (a <= -8.5e-139)
		tmp = c * (z * -b);
	elseif (a <= -1.5e-201)
		tmp = i * (y * -j);
	elseif (a <= 1.25e+39)
		tmp = x * (y * z);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -5.5e+31], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -8.5e-139], N[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.5e-201], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.25e+39], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 20: 50.9% accurate, 2.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -1.9 \cdot 10^{+51} \lor \neg \left(c \leq 4.6 \cdot 10^{-97}\right):\\ \;\;\;\;c \cdot \left(t \cdot j - z \cdot b\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 (<= c -1.9e+51) (not (<= c 4.6e-97)))
   (* c (- (* t j) (* z b)))
   (* 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 ((c <= -1.9e+51) || !(c <= 4.6e-97)) {
		tmp = c * ((t * j) - (z * b));
	} 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 ((c <= (-1.9d+51)) .or. (.not. (c <= 4.6d-97))) then
        tmp = c * ((t * j) - (z * b))
    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 ((c <= -1.9e+51) || !(c <= 4.6e-97)) {
		tmp = c * ((t * j) - (z * b));
	} else {
		tmp = x * ((y * z) - (t * a));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if (c <= -1.9e+51) or not (c <= 4.6e-97):
		tmp = c * ((t * j) - (z * b))
	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 ((c <= -1.9e+51) || !(c <= 4.6e-97))
		tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b)));
	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 ((c <= -1.9e+51) || ~((c <= 4.6e-97)))
		tmp = c * ((t * j) - (z * b));
	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[c, -1.9e+51], N[Not[LessEqual[c, 4.6e-97]], $MachinePrecision]], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 21: 30.2% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -9 \cdot 10^{+31}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;a \leq -1.2 \cdot 10^{-138}:\\ \;\;\;\;c \cdot \left(z \cdot \left(-b\right)\right)\\ \mathbf{elif}\;a \leq 5.2 \cdot 10^{+41}:\\ \;\;\;\;x \cdot \left(y \cdot z\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 (<= a -9e+31)
   (* b (* a i))
   (if (<= a -1.2e-138)
     (* c (* z (- b)))
     (if (<= a 5.2e+41) (* x (* y z)) (* 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 (a <= -9e+31) {
		tmp = b * (a * i);
	} else if (a <= -1.2e-138) {
		tmp = c * (z * -b);
	} else if (a <= 5.2e+41) {
		tmp = x * (y * z);
	} 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 (a <= (-9d+31)) then
        tmp = b * (a * i)
    else if (a <= (-1.2d-138)) then
        tmp = c * (z * -b)
    else if (a <= 5.2d+41) then
        tmp = x * (y * z)
    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 (a <= -9e+31) {
		tmp = b * (a * i);
	} else if (a <= -1.2e-138) {
		tmp = c * (z * -b);
	} else if (a <= 5.2e+41) {
		tmp = x * (y * z);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if a <= -9e+31:
		tmp = b * (a * i)
	elif a <= -1.2e-138:
		tmp = c * (z * -b)
	elif a <= 5.2e+41:
		tmp = x * (y * z)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (a <= -9e+31)
		tmp = Float64(b * Float64(a * i));
	elseif (a <= -1.2e-138)
		tmp = Float64(c * Float64(z * Float64(-b)));
	elseif (a <= 5.2e+41)
		tmp = Float64(x * Float64(y * z));
	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 (a <= -9e+31)
		tmp = b * (a * i);
	elseif (a <= -1.2e-138)
		tmp = c * (z * -b);
	elseif (a <= 5.2e+41)
		tmp = x * (y * z);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -9e+31], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.2e-138], N[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.2e+41], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 22: 29.8% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;i \leq -1.65 \cdot 10^{+195}:\\ \;\;\;\;j \cdot \left(-y \cdot i\right)\\ \mathbf{elif}\;i \leq -1.4 \cdot 10^{+77}:\\ \;\;\;\;b \cdot \left(a \cdot i\right)\\ \mathbf{elif}\;i \leq 2.6 \cdot 10^{+101}:\\ \;\;\;\;y \cdot \left(x \cdot z\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 (<= i -1.65e+195)
   (* j (- (* y i)))
   (if (<= i -1.4e+77)
     (* b (* a i))
     (if (<= i 2.6e+101) (* y (* x z)) (* 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 (i <= -1.65e+195) {
		tmp = j * -(y * i);
	} else if (i <= -1.4e+77) {
		tmp = b * (a * i);
	} else if (i <= 2.6e+101) {
		tmp = y * (x * z);
	} 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 (i <= (-1.65d+195)) then
        tmp = j * -(y * i)
    else if (i <= (-1.4d+77)) then
        tmp = b * (a * i)
    else if (i <= 2.6d+101) then
        tmp = y * (x * z)
    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 (i <= -1.65e+195) {
		tmp = j * -(y * i);
	} else if (i <= -1.4e+77) {
		tmp = b * (a * i);
	} else if (i <= 2.6e+101) {
		tmp = y * (x * z);
	} else {
		tmp = a * (b * i);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if i <= -1.65e+195:
		tmp = j * -(y * i)
	elif i <= -1.4e+77:
		tmp = b * (a * i)
	elif i <= 2.6e+101:
		tmp = y * (x * z)
	else:
		tmp = a * (b * i)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (i <= -1.65e+195)
		tmp = Float64(j * Float64(-Float64(y * i)));
	elseif (i <= -1.4e+77)
		tmp = Float64(b * Float64(a * i));
	elseif (i <= 2.6e+101)
		tmp = Float64(y * Float64(x * z));
	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 (i <= -1.65e+195)
		tmp = j * -(y * i);
	elseif (i <= -1.4e+77)
		tmp = b * (a * i);
	elseif (i <= 2.6e+101)
		tmp = y * (x * z);
	else
		tmp = a * (b * i);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.65e+195], N[(j * (-N[(y * i), $MachinePrecision])), $MachinePrecision], If[LessEqual[i, -1.4e+77], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.6e+101], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 23: 29.0% accurate, 3.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;j \leq -1 \cdot 10^{+21} \lor \neg \left(j \leq 120\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 (<= j -1e+21) (not (<= j 120.0))) (* 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 ((j <= -1e+21) || !(j <= 120.0)) {
		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 ((j <= (-1d+21)) .or. (.not. (j <= 120.0d0))) 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 ((j <= -1e+21) || !(j <= 120.0)) {
		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 (j <= -1e+21) or not (j <= 120.0):
		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 ((j <= -1e+21) || !(j <= 120.0))
		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 ((j <= -1e+21) || ~((j <= 120.0)))
		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[j, -1e+21], N[Not[LessEqual[j, 120.0]], $MachinePrecision]], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 24: 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

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Developer target: 69.7% 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 2024008 
(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)))))