Data.Colour.Matrix:determinant from colour-2.3.3, A

Percentage Accurate: 74.2% → 71.7%

Time: 26.8s

Alternatives: 12

Speedup: 1.0×

• 57.4% 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 - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right) \end{array} \]

FPCore

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

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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}

Python

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

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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i))))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j)
	tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 74.2% 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 - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right) \end{array} \]

FPCore

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

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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}

Python

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

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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i))))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j)
	tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 71.7% accurate, 0.9× speedup

Math

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

FPCore

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

C

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

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 = ((i * ((b * t) - (j * y))) + ((a * (j * c)) + (x * ((y * z) - (t * a))))) - (b * (c * z))
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 ((i * ((b * t) - (j * y))) + ((a * (j * c)) + (x * ((y * z) - (t * a))))) - (b * (c * z));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in i around -inf 79.3%

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

4. Final simplification 79.3%

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

Alternative 2: 74.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(i \cdot t - c \cdot z\right)\right) + j \cdot \left(a \cdot c - 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 (- (* i t) (* c z))))
  (* j (- (* a c) (* 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 * ((i * t) - (c * z)))) + (j * ((a * c) - (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 * ((i * t) - (c * z)))) + (j * ((a * c) - (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 * ((i * t) - (c * z)))) + (j * ((a * c) - (i * y)));
}

Python

def code(x, y, z, t, a, b, c, i, j):
	return ((x * ((y * z) - (t * a))) + (b * ((i * t) - (c * z)))) + (j * ((a * c) - (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(i * t) - Float64(c * z)))) + Float64(j * Float64(Float64(a * c) - Float64(i * y))))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i, j)
	tmp = ((x * ((y * z) - (t * a))) + (b * ((i * t) - (c * z)))) + (j * ((a * c) - (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[(i * t), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(a * c), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 77.9%

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

3. Final simplification 77.9%

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

Alternative 3: 67.4% accurate, 1.2× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in y around inf 67.4%

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

   1. *-commutative 67.4%

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

   2. *-commutative 67.4%

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

   3. associate-*l* 69.0%

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

5. Simplified 69.0%

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

6. Final simplification 69.0%

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

Alternative 4: 59.9% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

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 = (b * ((i * t) - (c * z))) - (j * ((i * y) - (a * c)))
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 (b * ((i * t) - (c * z))) - (j * ((i * y) - (a * c)));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in x around 0 60.5%

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

   1. *-commutative 60.5%

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

5. Simplified 60.5%

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

6. Final simplification 60.5%

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

Alternative 5: 59.6% accurate, 1.5× speedup

Math

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

FPCore

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

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 * ((i * t) - (c * z)));
}

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 * ((i * t) - (c * z)))
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 * ((i * t) - (c * z)));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in j around 0 63.5%

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

   1. *-commutative 63.5%

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

   2. *-commutative 63.5%

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

5. Simplified 63.5%

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

6. Final simplification 63.5%

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

Alternative 6: 51.1% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

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 = (j * ((a * c) - (i * y))) - (c * (b * z))
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 (j * ((a * c) - (i * y))) - (c * (b * z));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in x around 0 60.5%

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

   1. *-commutative 60.5%

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

5. Simplified 60.5%

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

6. Taylor expanded in c around inf 48.1%

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

   1. *-commutative 48.1%

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

   2. associate-*l* 47.2%

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

8. Simplified 47.2%

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

9. Final simplification 47.2%

   \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) - c \cdot \left(b \cdot z\right) \]
10. Add Preprocessing

Alternative 7: 49.4% accurate, 1.9× speedup

Math

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

FPCore

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

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

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in j around 0 63.5%

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

   1. *-commutative 63.5%

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

   2. *-commutative 63.5%

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

5. Simplified 63.5%

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

6. Taylor expanded in c around inf 51.9%

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

   1. *-commutative 48.1%

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

   2. associate-*l* 47.2%

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

8. Simplified 49.8%

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

9. Final simplification 49.8%

   \[\leadsto x \cdot \left(y \cdot z - t \cdot a\right) - c \cdot \left(b \cdot z\right) \]
10. Add Preprocessing

Alternative 8: 39.2% accurate, 3.2× speedup

Math

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

FPCore

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

C

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

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 * ((j * c) - (t * x))
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 * ((j * c) - (t * x));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in a around inf 40.8%

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

   1. +-commutative 40.8%

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

   2. mul-1-neg 40.8%

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

   3. unsub-neg 40.8%

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

5. Simplified 40.8%

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

6. Final simplification 40.8%

   \[\leadsto a \cdot \left(j \cdot c - t \cdot x\right) \]
7. Add Preprocessing

Alternative 9: 39.1% accurate, 3.2× speedup

Math

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

FPCore

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

C

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

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 = b * ((i * t) - (c * z))
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 b * ((i * t) - (c * z));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in b around inf 43.3%

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

4. Final simplification 43.3%

   \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) \]
5. Add Preprocessing

Alternative 10: 22.2% accurate, 5.8× speedup

Math

\[\begin{array}{l} \\ a \cdot \left(j \cdot c\right) \end{array} \]

FPCore

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

C

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

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 * (j * c)
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 * (j * c);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in a around inf 40.8%

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

   1. +-commutative 40.8%

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

   2. mul-1-neg 40.8%

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

   3. unsub-neg 40.8%

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

5. Simplified 40.8%

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

6. Taylor expanded in c around inf 22.1%

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

   1. *-commutative 22.1%

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

8. Simplified 22.1%

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

9. Final simplification 22.1%

   \[\leadsto a \cdot \left(j \cdot c\right) \]
10. Add Preprocessing

Alternative 11: 22.1% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in j around 0 63.5%

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

   1. *-commutative 63.5%

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

   2. *-commutative 63.5%

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

5. Simplified 63.5%

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

6. Taylor expanded in i around inf 23.4%

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

7. Final simplification 23.4%

   \[\leadsto b \cdot \left(i \cdot t\right) \]
8. Add Preprocessing

Alternative 12: 22.0% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 77.9%

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

3. Taylor expanded in i around inf 39.8%

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

   1. distribute-lft-out-- 39.8%

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

5. Simplified 39.8%

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

6. Taylor expanded in j around 0 23.4%

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

8. Simplified 23.4%

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

9. Taylor expanded in b around 0 23.4%

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

    1. *-commutative 23.4%

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

    2. associate-*l* 26.3%

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

    3. *-commutative 26.3%

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

11. Simplified 26.3%

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

12. Final simplification 26.3%

    \[\leadsto i \cdot \left(b \cdot t\right) \]
13. Add Preprocessing

Developer target: 59.8% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := j \cdot \left(c \cdot a - y \cdot i\right)\\ t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - \frac{b \cdot \left({\left(c \cdot z\right)}^{2} - {\left(t \cdot i\right)}^{2}\right)}{c \cdot z + t \cdot i}\right) + t\_1\\ \mathbf{if}\;x < -1.469694296777705 \cdot 10^{-64}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;x < 3.2113527362226803 \cdot 10^{-147}:\\ \;\;\;\;\left(b \cdot i - x \cdot a\right) \cdot t - \left(z \cdot \left(c \cdot b\right) - t\_1\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (let* ((t_1 (* j (- (* c a) (* y i))))
        (t_2
         (+
          (-
           (* x (- (* y z) (* t a)))
           (/
            (* b (- (pow (* c z) 2.0) (pow (* t i) 2.0)))
            (+ (* c z) (* t i))))
          t_1)))
   (if (< x -1.469694296777705e-64)
     t_2
     (if (< x 3.2113527362226803e-147)
       (- (* (- (* b i) (* x a)) t) (- (* z (* c b)) 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 * ((c * a) - (y * i));
	double t_2 = ((x * ((y * z) - (t * a))) - ((b * (pow((c * z), 2.0) - pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
	double tmp;
	if (x < -1.469694296777705e-64) {
		tmp = t_2;
	} else if (x < 3.2113527362226803e-147) {
		tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 * ((c * a) - (y * i))
    t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ** 2.0d0) - ((t * i) ** 2.0d0))) / ((c * z) + (t * i)))) + t_1
    if (x < (-1.469694296777705d-64)) then
        tmp = t_2
    else if (x < 3.2113527362226803d-147) then
        tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 * ((c * a) - (y * i));
	double t_2 = ((x * ((y * z) - (t * a))) - ((b * (Math.pow((c * z), 2.0) - Math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
	double tmp;
	if (x < -1.469694296777705e-64) {
		tmp = t_2;
	} else if (x < 3.2113527362226803e-147) {
		tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((c * a) - (y * i))
	t_2 = ((x * ((y * z) - (t * a))) - ((b * (math.pow((c * z), 2.0) - math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1
	tmp = 0
	if x < -1.469694296777705e-64:
		tmp = t_2
	elif x < 3.2113527362226803e-147:
		tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1)
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(c * a) - Float64(y * i)))
	t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(Float64(b * Float64((Float64(c * z) ^ 2.0) - (Float64(t * i) ^ 2.0))) / Float64(Float64(c * z) + Float64(t * i)))) + t_1)
	tmp = 0.0
	if (x < -1.469694296777705e-64)
		tmp = t_2;
	elseif (x < 3.2113527362226803e-147)
		tmp = Float64(Float64(Float64(Float64(b * i) - Float64(x * a)) * t) - Float64(Float64(z * Float64(c * b)) - 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 * ((c * a) - (y * i));
	t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ^ 2.0) - ((t * i) ^ 2.0))) / ((c * z) + (t * i)))) + t_1;
	tmp = 0.0;
	if (x < -1.469694296777705e-64)
		tmp = t_2;
	elseif (x < 3.2113527362226803e-147)
		tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[Power[N[(c * z), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(t * i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * z), $MachinePrecision] + N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[Less[x, -1.469694296777705e-64], t$95$2, If[Less[x, 3.2113527362226803e-147], N[(N[(N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] - N[(N[(z * N[(c * b), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]

Reproduce

herbie shell --seed 2024033 
(FPCore (x y z t a b c i j)
  :name "Data.Colour.Matrix:determinant from colour-2.3.3, A"
  :precision binary64

  :herbie-target
  (if (< x -1.469694296777705e-64) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2.0) (pow (* t i) 2.0))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))) (if (< x 3.2113527362226803e-147) (- (* (- (* b i) (* x a)) t) (- (* z (* c b)) (* j (- (* c a) (* y i))))) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2.0) (pow (* t i) 2.0))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i))))))

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