Linear.Matrix:det33 from linear-1.19.1.3

Percentage Accurate: 73.6% → 75.7%

Time: 18.4s

Alternatives: 10

Speedup: 1.0×

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

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 73.6% 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: 75.7% accurate, 0.1× speedup

Math

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

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 75.7%

   \[\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right) \]
2. Step-by-step derivation

   1. +-commutative 75.7%

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

   2. fma-def 76.9%

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

   3. *-commutative 76.9%

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

   4. *-commutative 76.9%

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

   5. cancel-sign-sub-inv 76.9%

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

   6. cancel-sign-sub 76.9%

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

   7. fma-neg 77.3%

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

   8. distribute-rgt-neg-out 77.3%

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

   9. remove-double-neg 77.3%

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

   10. *-commutative 77.3%

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

   11. *-commutative 77.3%

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

3. Simplified 77.3%

   \[\leadsto \color{blue}{\mathsf{fma}\left(j, t \cdot c - y \cdot i, x \cdot \mathsf{fma}\left(y, z, t \cdot \left(-a\right)\right) - b \cdot \left(z \cdot c - a \cdot i\right)\right)} \]
4. Add Preprocessing

5. Final simplification 77.3%

   \[\leadsto \mathsf{fma}\left(j, t \cdot c - y \cdot i, x \cdot \mathsf{fma}\left(y, z, a \cdot \left(-t\right)\right) + b \cdot \left(i \cdot a - c \cdot z\right)\right) \]
6. Add Preprocessing

Alternative 2: 73.6% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
 :precision binary64
 (-
  (* j (- (* t c) (* y i)))
  (- (* b (- (* c z) (* i a))) (* 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) {
	return (j * ((t * c) - (y * i))) - ((b * ((c * z) - (i * a))) - (x * ((y * z) - (t * a))));
}

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Final simplification 75.7%

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

Alternative 3: 66.2% accurate, 1.2× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    code = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (z * (c * b)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in c around inf 67.8%

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

   1. associate-*r* 46.6%

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

   2. *-commutative 46.6%

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

5. Simplified 68.9%

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

6. Final simplification 68.9%

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

Alternative 4: 58.6% accurate, 1.5× speedup

Math

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

FPCore

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

Python

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

Julia

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

MATLAB

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in b around 0 62.1%

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

4. Final simplification 62.1%

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

Alternative 5: 49.8% accurate, 1.9× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    code = (j * ((t * c) - (y * i))) - (z * (c * b))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in x around 0 56.8%

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

   1. *-commutative 56.8%

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

5. Simplified 56.8%

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

6. Taylor expanded in c around inf 45.5%

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

   1. associate-*r* 46.6%

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

   2. *-commutative 46.6%

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

8. Simplified 46.6%

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

9. Final simplification 46.6%

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

Alternative 6: 39.6% accurate, 3.2× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j) :precision binary64 (* b (- (* i a) (* 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 * a) - (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 * a) - (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 * a) - (c * z));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in b around inf 39.9%

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

   1. *-commutative 39.9%

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

5. Simplified 39.9%

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

6. Final simplification 39.9%

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

Alternative 7: 39.3% accurate, 3.2× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j) :precision binary64 (* a (- (* i b) (* 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 * ((i * b) - (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 * ((i * b) - (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 * ((i * b) - (t * x));
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in a around -inf 41.5%

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

4. Final simplification 41.5%

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

Alternative 8: 22.7% accurate, 4.8× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    code = c * (z * -b)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in z around inf 35.8%

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

   1. *-commutative 35.8%

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

   2. *-commutative 35.8%

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

5. Simplified 35.8%

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

6. Taylor expanded in y around 0 21.6%

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

   1. neg-mul-1 21.6%

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

   2. distribute-lft-neg-in 21.6%

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

   3. *-commutative 21.6%

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

   4. associate-*l* 23.7%

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

8. Simplified 23.7%

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

9. Final simplification 23.7%

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

Alternative 9: 22.7% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    code = a * (i * b)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in b around inf 39.9%

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

   1. *-commutative 39.9%

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

5. Simplified 39.9%

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

6. Taylor expanded in i around inf 22.7%

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

7. Final simplification 22.7%

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

Alternative 10: 22.7% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

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 * a)
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 * a);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 75.7%

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

3. Taylor expanded in b around inf 39.9%

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

   1. *-commutative 39.9%

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

5. Simplified 39.9%

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

6. Taylor expanded in i around inf 23.4%

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

7. Final simplification 23.4%

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

Developer target: 68.9% 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 2024033 
(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)))))