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

Percentage Accurate: 73.5% → 82.3%

Time: 6.7s

Alternatives: 26

Speedup: 0.5×

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

Specification

Math

\[\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) \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (+
 (- (* 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)
use fmin_fmax_functions
    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]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
END code

Initial Program: 73.5% accurate, 1.0× speedup

Math

\[\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) \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (+
 (- (* 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)
use fmin_fmax_functions
    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]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
END code

Alternative 1: 82.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_1 := \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)\\ \mathbf{if}\;t\_1 \leq \infty:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (+
         (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i))))
         (* j (- (* c a) (* y i))))))
  (if (<= t_1 INFINITY) t_1 (* (fma b t (- (* j y))) 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) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = t_1;
	} else {
		tmp = fma(b, t, -(j * y)) * i;
	}
	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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i))))
	tmp = 0.0
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = Float64(fma(b, t, Float64(-Float64(j * y))) * i);
	end
	return 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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(b * t + (-N[(j * y), $MachinePrecision])), $MachinePrecision] * i), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

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

   1. Initial program 73.5%

      \[\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) \]

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

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
   7. Step-by-step derivation

   8. Applied rewrites 38.9%

      \[\leadsto \mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 70.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} \mathbf{if}\;i \leq -3.7101518059885436 \cdot 10^{+142}:\\ \;\;\;\;\mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i\\ \mathbf{elif}\;i \leq 3.6011085405573053 \cdot 10^{-140}:\\ \;\;\;\;\mathsf{fma}\left(a, c \cdot j, x \cdot \left(y \cdot z - a \cdot t\right)\right) - b \cdot \left(c \cdot z\right)\\ \mathbf{elif}\;i \leq 4.790183947989663 \cdot 10^{+53}:\\ \;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot a - y \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;\left(b \cdot t - j \cdot y\right) \cdot i\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= i -3.7101518059885436e+142)
  (* (fma b t (- (* j y))) i)
  (if (<= i 3.6011085405573053e-140)
    (- (fma a (* c j) (* x (- (* y z) (* a t)))) (* b (* c z)))
    (if (<= i 4.790183947989663e+53)
      (+ (* z (- (* x y) (* b c))) (* j (- (* c a) (* y i))))
      (* (- (* b t) (* j y)) 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 <= -3.7101518059885436e+142) {
		tmp = fma(b, t, -(j * y)) * i;
	} else if (i <= 3.6011085405573053e-140) {
		tmp = fma(a, (c * j), (x * ((y * z) - (a * t)))) - (b * (c * z));
	} else if (i <= 4.790183947989663e+53) {
		tmp = (z * ((x * y) - (b * c))) + (j * ((c * a) - (y * i)));
	} else {
		tmp = ((b * t) - (j * y)) * i;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (i <= -3.7101518059885436e+142)
		tmp = Float64(fma(b, t, Float64(-Float64(j * y))) * i);
	elseif (i <= 3.6011085405573053e-140)
		tmp = Float64(fma(a, Float64(c * j), Float64(x * Float64(Float64(y * z) - Float64(a * t)))) - Float64(b * Float64(c * z)));
	elseif (i <= 4.790183947989663e+53)
		tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + Float64(j * Float64(Float64(c * a) - Float64(y * i))));
	else
		tmp = Float64(Float64(Float64(b * t) - Float64(j * y)) * i);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -3.7101518059885436e+142], N[(N[(b * t + (-N[(j * y), $MachinePrecision])), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, 3.6011085405573053e-140], N[(N[(a * N[(c * j), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4.790183947989663e+53], N[(N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * t), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET tmp_2 = IF (i <= (479018394798966288412678141312024785768468370543345664)) THEN ((z * ((x * y) - (b * c))) + (j * ((c * a) - (y * i)))) ELSE (((b * t) - (j * y)) * i) ENDIF IN
	LET tmp_1 = IF (i <= (36011085405573052592928021721067046740608025566946438111917136141466486166168828736992202063017461208648401410729786589937401861535351393188765616954534692655219528317094156836734078647430114217272496390709340018955070935448026673323434732337957759895244753658404812241942038472492054225580588105128152515371501608376777858037230011824247899454576327116228640079498291015625e-513)) THEN (((a * (c * j)) + (x * ((y * z) - (a * t)))) - (b * (c * z))) ELSE tmp_2 ENDIF IN
	LET tmp = IF (i <= (-37101518059885436398804382341998676040814336404473112029801678952473302513158296370695176770777187777010473703093495049212120292360749624328192)) THEN (((b * t) + (- (j * y))) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if i < -3.7101518059885436e142

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
   7. Step-by-step derivation

   8. Applied rewrites 38.9%

      \[\leadsto \mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i \]

   if -3.7101518059885436e142 < i < 3.6011085405573053e-140

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around 0

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

   4. Applied rewrites 59.4%

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

   if 3.6011085405573053e-140 < i < 4.7901839479896629e53

   1. Initial program 73.5%

      \[\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. Taylor expanded in z around inf

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

   4. Applied rewrites 59.8%

      \[\leadsto z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   if 4.7901839479896629e53 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 69.1% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* j (- (* c a) (* y i))))
       (t_2 (+ (* -1.0 (* t (- (* a x) (* b i)))) t_1)))
  (if (<= t -6.249185407397577e+49)
    t_2
    (if (<= t 58932126.29484374)
      (+ (* z (- (* x y) (* b c))) 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 = (-1.0 * (t * ((a * x) - (b * i)))) + t_1;
	double tmp;
	if (t <= -6.249185407397577e+49) {
		tmp = t_2;
	} else if (t <= 58932126.29484374) {
		tmp = (z * ((x * y) - (b * c))) + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 = ((-1.0d0) * (t * ((a * x) - (b * i)))) + t_1
    if (t <= (-6.249185407397577d+49)) then
        tmp = t_2
    else if (t <= 58932126.29484374d0) then
        tmp = (z * ((x * y) - (b * c))) + 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 = (-1.0 * (t * ((a * x) - (b * i)))) + t_1;
	double tmp;
	if (t <= -6.249185407397577e+49) {
		tmp = t_2;
	} else if (t <= 58932126.29484374) {
		tmp = (z * ((x * y) - (b * c))) + 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 = (-1.0 * (t * ((a * x) - (b * i)))) + t_1
	tmp = 0
	if t <= -6.249185407397577e+49:
		tmp = t_2
	elif t <= 58932126.29484374:
		tmp = (z * ((x * y) - (b * c))) + 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(-1.0 * Float64(t * Float64(Float64(a * x) - Float64(b * i)))) + t_1)
	tmp = 0.0
	if (t <= -6.249185407397577e+49)
		tmp = t_2;
	elseif (t <= 58932126.29484374)
		tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + 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 = (-1.0 * (t * ((a * x) - (b * i)))) + t_1;
	tmp = 0.0;
	if (t <= -6.249185407397577e+49)
		tmp = t_2;
	elseif (t <= 58932126.29484374)
		tmp = (z * ((x * y) - (b * c))) + 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[(-1.0 * N[(t * N[(N[(a * x), $MachinePrecision] - N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[t, -6.249185407397577e+49], t$95$2, If[LessEqual[t, 58932126.29484374], N[(N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], t$95$2]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (j * ((c * a) - (y * i))) IN
		LET t_2 = (((-1) * (t * ((a * x) - (b * i)))) + t_1) IN
			LET tmp_1 = IF (t <= (58932126294843740761280059814453125e-27)) THEN ((z * ((x * y) - (b * c))) + t_1) ELSE t_2 ENDIF IN
			LET tmp = IF (t <= (-62491854073975773637285687674448501086628958175232)) THEN t_2 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -6.2491854073975774e49 or 58932126.294843741 < t

   1. Initial program 73.5%

      \[\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. Taylor expanded in t around -inf

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

   4. Applied rewrites 58.9%

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

   if -6.2491854073975774e49 < t < 58932126.294843741

   1. Initial program 73.5%

      \[\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. Taylor expanded in z around inf

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

   4. Applied rewrites 59.8%

      \[\leadsto z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 68.8% accurate, 1.2× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* t (- (* b i) (* a x)))))
  (if (<= t -2.3413298739703848e+114)
    t_1
    (if (<= t 4.321062839219051e+94)
      (+ (* z (- (* x y) (* b c))) (* j (- (* c a) (* 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 = t * ((b * i) - (a * x));
	double tmp;
	if (t <= -2.3413298739703848e+114) {
		tmp = t_1;
	} else if (t <= 4.321062839219051e+94) {
		tmp = (z * ((x * y) - (b * c))) + (j * ((c * a) - (y * i)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 = t * ((b * i) - (a * x))
    if (t <= (-2.3413298739703848d+114)) then
        tmp = t_1
    else if (t <= 4.321062839219051d+94) then
        tmp = (z * ((x * y) - (b * c))) + (j * ((c * a) - (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 = t * ((b * i) - (a * x));
	double tmp;
	if (t <= -2.3413298739703848e+114) {
		tmp = t_1;
	} else if (t <= 4.321062839219051e+94) {
		tmp = (z * ((x * y) - (b * c))) + (j * ((c * a) - (y * i)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(t * Float64(Float64(b * i) - Float64(a * x)))
	tmp = 0.0
	if (t <= -2.3413298739703848e+114)
		tmp = t_1;
	elseif (t <= 4.321062839219051e+94)
		tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + Float64(j * Float64(Float64(c * a) - 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 = t * ((b * i) - (a * x));
	tmp = 0.0;
	if (t <= -2.3413298739703848e+114)
		tmp = t_1;
	elseif (t <= 4.321062839219051e+94)
		tmp = (z * ((x * y) - (b * c))) + (j * ((c * a) - (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[(t * N[(N[(b * i), $MachinePrecision] - N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.3413298739703848e+114], t$95$1, If[LessEqual[t, 4.321062839219051e+94], N[(N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (t * ((b * i) - (a * x))) IN
		LET tmp_1 = IF (t <= (43210628392190507493955542397247136843294690070887094512136488627766935582293990174101266759680)) THEN ((z * ((x * y) - (b * c))) + (j * ((c * a) - (y * i)))) ELSE t_1 ENDIF IN
		LET tmp = IF (t <= (-2341329873970384826374455504945680588185662936904775436337583895386335494974267987393380268252854923798542586740736)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -2.3413298739703848e114 or 4.3210628392190507e94 < t

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in t around inf

      \[\leadsto t \cdot \left(b \cdot i - a \cdot x\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.0%

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

   if -2.3413298739703848e114 < t < 4.3210628392190507e94

   1. Initial program 73.5%

      \[\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. Taylor expanded in z around inf

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

   4. Applied rewrites 59.8%

      \[\leadsto z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 66.6% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(j, a \cdot c - i \cdot y, x \cdot \left(y \cdot z - a \cdot t\right)\right)\\ \mathbf{if}\;x \leq -4.618320426894498 \cdot 10^{+65}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 6.939907776387002 \cdot 10^{-57}:\\ \;\;\;\;b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma j (- (* a c) (* i y)) (* x (- (* y z) (* a t))))))
  (if (<= x -4.618320426894498e+65)
    t_1
    (if (<= x 6.939907776387002e-57)
      (+ (* b (- (* i t) (* c z))) (* j (- (* c a) (* 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 = fma(j, ((a * c) - (i * y)), (x * ((y * z) - (a * t))));
	double tmp;
	if (x <= -4.618320426894498e+65) {
		tmp = t_1;
	} else if (x <= 6.939907776387002e-57) {
		tmp = (b * ((i * t) - (c * z))) + (j * ((c * a) - (y * i)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = fma(j, Float64(Float64(a * c) - Float64(i * y)), Float64(x * Float64(Float64(y * z) - Float64(a * t))))
	tmp = 0.0
	if (x <= -4.618320426894498e+65)
		tmp = t_1;
	elseif (x <= 6.939907776387002e-57)
		tmp = Float64(Float64(b * Float64(Float64(i * t) - Float64(c * z))) + Float64(j * Float64(Float64(c * a) - Float64(y * i))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = ((j * ((a * c) - (i * y))) + (x * ((y * z) - (a * t)))) IN
		LET tmp_1 = IF (x <= (693990777638700173209054315246154302859828518470894496344856266768865254679087321507143014986153324136577447776799795266106192915212002954501203932924369155443855561316013336181640625e-239)) THEN ((b * ((i * t) - (c * z))) + (j * ((c * a) - (y * i)))) ELSE t_1 ENDIF IN
		LET tmp = IF (x <= (-461832042689449774430702640100661705034977822929688004618732175360)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if x < -4.6183204268944977e65 or 6.9399077763870017e-57 < x

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   if -4.6183204268944977e65 < x < 6.9399077763870017e-57

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around inf

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

   4. Applied rewrites 58.4%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 66.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(j, c \cdot a, \left(i \cdot t - c \cdot z\right) \cdot b\right)\\ \mathbf{if}\;b \leq -1.2792350246156161 \cdot 10^{+39}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 5.0054787334215 \cdot 10^{+137}:\\ \;\;\;\;\mathsf{fma}\left(j, a \cdot c - i \cdot y, x \cdot \left(y \cdot z - a \cdot t\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma j (* c a) (* (- (* i t) (* c z)) b))))
  (if (<= b -1.2792350246156161e+39)
    t_1
    (if (<= b 5.0054787334215e+137)
      (fma j (- (* a c) (* i y)) (* x (- (* y z) (* a t))))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = fma(j, (c * a), (((i * t) - (c * z)) * b));
	double tmp;
	if (b <= -1.2792350246156161e+39) {
		tmp = t_1;
	} else if (b <= 5.0054787334215e+137) {
		tmp = fma(j, ((a * c) - (i * y)), (x * ((y * z) - (a * t))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = fma(j, Float64(c * a), Float64(Float64(Float64(i * t) - Float64(c * z)) * b))
	tmp = 0.0
	if (b <= -1.2792350246156161e+39)
		tmp = t_1;
	elseif (b <= 5.0054787334215e+137)
		tmp = fma(j, Float64(Float64(a * c) - Float64(i * y)), Float64(x * Float64(Float64(y * z) - Float64(a * t))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = ((j * (c * a)) + (((i * t) - (c * z)) * b)) IN
		LET tmp_1 = IF (b <= (500547873342150005003162540602698535195471489758711811983043794225700205627234978864226352966123520666630414563391502613792670758912131072)) THEN ((j * ((a * c) - (i * y))) + (x * ((y * z) - (a * t)))) ELSE t_1 ENDIF IN
		LET tmp = IF (b <= (-1279235024615616085937416255915178328064)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if b < -1.2792350246156161e39 or 5.0054787334215001e137 < b

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around inf

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

   4. Applied rewrites 58.4%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 48.7%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(a \cdot c\right) \]

   9. Applied rewrites 49.7%

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

   if -1.2792350246156161e39 < b < 5.0054787334215001e137

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

      \[\leadsto \mathsf{fma}\left(j, a \cdot c - i \cdot y, x \cdot \left(y \cdot z - a \cdot t\right)\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 59.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -2.240192610486443 \cdot 10^{-9}:\\ \;\;\;\;\mathsf{fma}\left(j, c \cdot a, \left(i \cdot t - c \cdot z\right) \cdot b\right)\\ \mathbf{elif}\;c \leq 1.3727925780282034 \cdot 10^{-39}:\\ \;\;\;\;\mathsf{fma}\left(-1, i \cdot \left(j \cdot y\right), x \cdot \left(y \cdot z - a \cdot t\right)\right)\\ \mathbf{elif}\;c \leq 5.0410344590420615 \cdot 10^{+137}:\\ \;\;\;\;b \cdot \mathsf{fma}\left(i, t, \left(-z\right) \cdot c\right) + j \cdot \left(a \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;c \cdot \left(a \cdot j - b \cdot z\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -2.240192610486443e-9)
  (fma j (* c a) (* (- (* i t) (* c z)) b))
  (if (<= c 1.3727925780282034e-39)
    (fma -1.0 (* i (* j y)) (* x (- (* y z) (* a t))))
    (if (<= c 5.0410344590420615e+137)
      (+ (* b (fma i t (* (- z) c))) (* j (* a c)))
      (* c (- (* a j) (* b z)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -2.240192610486443e-9) {
		tmp = fma(j, (c * a), (((i * t) - (c * z)) * b));
	} else if (c <= 1.3727925780282034e-39) {
		tmp = fma(-1.0, (i * (j * y)), (x * ((y * z) - (a * t))));
	} else if (c <= 5.0410344590420615e+137) {
		tmp = (b * fma(i, t, (-z * c))) + (j * (a * c));
	} else {
		tmp = c * ((a * j) - (b * z));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -2.240192610486443e-9)
		tmp = fma(j, Float64(c * a), Float64(Float64(Float64(i * t) - Float64(c * z)) * b));
	elseif (c <= 1.3727925780282034e-39)
		tmp = fma(-1.0, Float64(i * Float64(j * y)), Float64(x * Float64(Float64(y * z) - Float64(a * t))));
	elseif (c <= 5.0410344590420615e+137)
		tmp = Float64(Float64(b * fma(i, t, Float64(Float64(-z) * c))) + Float64(j * Float64(a * c)));
	else
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -2.240192610486443e-9], N[(j * N[(c * a), $MachinePrecision] + N[(N[(N[(i * t), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.3727925780282034e-39], N[(-1.0 * N[(i * N[(j * y), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.0410344590420615e+137], N[(N[(b * N[(i * t + N[((-z) * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * N[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET tmp_2 = IF (c <= (504103445904206154370187039114831329655839318726770702096060187536639831678564467845447041389166961643335463175862626989960089024220626944)) THEN ((b * ((i * t) + ((- z) * c))) + (j * (a * c))) ELSE (c * ((a * j) - (b * z))) ENDIF IN
	LET tmp_1 = IF (c <= (13727925780282033981308336653106067515233874189549362374482081473567896483204584383907246636596409332907453570982170276693068444728851318359375e-181)) THEN (((-1) * (i * (j * y))) + (x * ((y * z) - (a * t)))) ELSE tmp_2 ENDIF IN
	LET tmp = IF (c <= (-224019261048644314265724475864448306250409359563491307199001312255859375e-80)) THEN ((j * (c * a)) + (((i * t) - (c * z)) * b)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if c < -2.2401926104864431e-9

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around inf

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

   4. Applied rewrites 58.4%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 48.7%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(a \cdot c\right) \]

   9. Applied rewrites 49.7%

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

   if -2.2401926104864431e-9 < c < 1.3727925780282034e-39

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   5. Taylor expanded in c around 0

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) + x \cdot \left(y \cdot z - a \cdot t\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 50.0%

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

   if 1.3727925780282034e-39 < c < 5.0410344590420615e137

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around inf

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

   4. Applied rewrites 58.4%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 48.7%

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

   9. Applied rewrites 49.0%

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

   if 5.0410344590420615e137 < c

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 8: 58.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := t \cdot \left(b \cdot i - a \cdot x\right)\\ \mathbf{if}\;t \leq -2.0656690511715 \cdot 10^{+114}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq -2.7761774807783018 \cdot 10^{-124}:\\ \;\;\;\;b \cdot \left(i \cdot t\right) + j \cdot \left(c \cdot a - y \cdot i\right)\\ \mathbf{elif}\;t \leq 4.321062839219051 \cdot 10^{+94}:\\ \;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(a \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* t (- (* b i) (* a x)))))
  (if (<= t -2.0656690511715e+114)
    t_1
    (if (<= t -2.7761774807783018e-124)
      (+ (* b (* i t)) (* j (- (* c a) (* y i))))
      (if (<= t 4.321062839219051e+94)
        (+ (* z (- (* x y) (* b c))) (* j (* a c)))
        t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = t * ((b * i) - (a * x));
	double tmp;
	if (t <= -2.0656690511715e+114) {
		tmp = t_1;
	} else if (t <= -2.7761774807783018e-124) {
		tmp = (b * (i * t)) + (j * ((c * a) - (y * i)));
	} else if (t <= 4.321062839219051e+94) {
		tmp = (z * ((x * y) - (b * c))) + (j * (a * c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 = t * ((b * i) - (a * x))
    if (t <= (-2.0656690511715d+114)) then
        tmp = t_1
    else if (t <= (-2.7761774807783018d-124)) then
        tmp = (b * (i * t)) + (j * ((c * a) - (y * i)))
    else if (t <= 4.321062839219051d+94) then
        tmp = (z * ((x * y) - (b * c))) + (j * (a * c))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = t * ((b * i) - (a * x));
	double tmp;
	if (t <= -2.0656690511715e+114) {
		tmp = t_1;
	} else if (t <= -2.7761774807783018e-124) {
		tmp = (b * (i * t)) + (j * ((c * a) - (y * i)));
	} else if (t <= 4.321062839219051e+94) {
		tmp = (z * ((x * y) - (b * c))) + (j * (a * c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = t * ((b * i) - (a * x))
	tmp = 0
	if t <= -2.0656690511715e+114:
		tmp = t_1
	elif t <= -2.7761774807783018e-124:
		tmp = (b * (i * t)) + (j * ((c * a) - (y * i)))
	elif t <= 4.321062839219051e+94:
		tmp = (z * ((x * y) - (b * c))) + (j * (a * c))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(t * Float64(Float64(b * i) - Float64(a * x)))
	tmp = 0.0
	if (t <= -2.0656690511715e+114)
		tmp = t_1;
	elseif (t <= -2.7761774807783018e-124)
		tmp = Float64(Float64(b * Float64(i * t)) + Float64(j * Float64(Float64(c * a) - Float64(y * i))));
	elseif (t <= 4.321062839219051e+94)
		tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + Float64(j * Float64(a * c)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = t * ((b * i) - (a * x));
	tmp = 0.0;
	if (t <= -2.0656690511715e+114)
		tmp = t_1;
	elseif (t <= -2.7761774807783018e-124)
		tmp = (b * (i * t)) + (j * ((c * a) - (y * i)));
	elseif (t <= 4.321062839219051e+94)
		tmp = (z * ((x * y) - (b * c))) + (j * (a * c));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (t * ((b * i) - (a * x))) IN
		LET tmp_2 = IF (t <= (43210628392190507493955542397247136843294690070887094512136488627766935582293990174101266759680)) THEN ((z * ((x * y) - (b * c))) + (j * (a * c))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (t <= (-2776177480778301786829539222788868220208723463045978436111367961079983546749505872129953601053344634618560429708302811785615968453162572966915341855612145237893052953283174398431123587969157134049674138966632542719613175129241148315683940062604148375783604078615895467315612793321535317470030683061239795694774556977790780365467071533203125e-463)) THEN ((b * (i * t)) + (j * ((c * a) - (y * i)))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (t <= (-2065669051171500023412655787111723096507854841471903831758418900202110551572374256222376369150470578015173640978432)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -2.0656690511715e114 or 4.3210628392190507e94 < t

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in t around inf

      \[\leadsto t \cdot \left(b \cdot i - a \cdot x\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.0%

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

   if -2.0656690511715e114 < t < -2.7761774807783018e-124

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around inf

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

   4. Applied rewrites 48.9%

      \[\leadsto b \cdot \left(i \cdot t\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   if -2.7761774807783018e-124 < t < 4.3210628392190507e94

   1. Initial program 73.5%

      \[\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. Taylor expanded in z around inf

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

   4. Applied rewrites 59.8%

      \[\leadsto z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 49.8%

      \[\leadsto z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(a \cdot c\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 9: 53.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(j, c \cdot a, \left(i \cdot t - c \cdot z\right) \cdot b\right)\\ \mathbf{if}\;c \leq -2.5786139262345718 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 6.66448639306518 \cdot 10^{-40}:\\ \;\;\;\;\left(z \cdot x - j \cdot i\right) \cdot y\\ \mathbf{elif}\;c \leq 5.0410344590420615 \cdot 10^{+137}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;c \cdot \left(a \cdot j - b \cdot z\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma j (* c a) (* (- (* i t) (* c z)) b))))
  (if (<= c -2.5786139262345718e-17)
    t_1
    (if (<= c 6.66448639306518e-40)
      (* (- (* z x) (* j i)) y)
      (if (<= c 5.0410344590420615e+137)
        t_1
        (* c (- (* a j) (* b z))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = fma(j, (c * a), (((i * t) - (c * z)) * b));
	double tmp;
	if (c <= -2.5786139262345718e-17) {
		tmp = t_1;
	} else if (c <= 6.66448639306518e-40) {
		tmp = ((z * x) - (j * i)) * y;
	} else if (c <= 5.0410344590420615e+137) {
		tmp = t_1;
	} else {
		tmp = c * ((a * j) - (b * z));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = fma(j, Float64(c * a), Float64(Float64(Float64(i * t) - Float64(c * z)) * b))
	tmp = 0.0
	if (c <= -2.5786139262345718e-17)
		tmp = t_1;
	elseif (c <= 6.66448639306518e-40)
		tmp = Float64(Float64(Float64(z * x) - Float64(j * i)) * y);
	elseif (c <= 5.0410344590420615e+137)
		tmp = t_1;
	else
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	end
	return tmp
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = ((j * (c * a)) + (((i * t) - (c * z)) * b)) IN
		LET tmp_2 = IF (c <= (504103445904206154370187039114831329655839318726770702096060187536639831678564467845447041389166961643335463175862626989960089024220626944)) THEN t_1 ELSE (c * ((a * j) - (b * z))) ENDIF IN
		LET tmp_1 = IF (c <= (66644863930651801345954019332756471842739672686487184383890881809443405296573995052258863380629486279638218348964073811657726764678955078125e-179)) THEN (((z * x) - (j * i)) * y) ELSE tmp_2 ENDIF IN
		LET tmp = IF (c <= (-25786139262345717808987900091445242821239345706765648535974122523839469067752361297607421875e-108)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -2.5786139262345718e-17 or 6.6644863930651801e-40 < c < 5.0410344590420615e137

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around inf

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

   4. Applied rewrites 58.4%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(c \cdot a - y \cdot i\right) \]

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 48.7%

      \[\leadsto b \cdot \left(i \cdot t - c \cdot z\right) + j \cdot \left(a \cdot c\right) \]

   9. Applied rewrites 49.7%

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

   if -2.5786139262345718e-17 < c < 6.6644863930651801e-40

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   if 5.0410344590420615e137 < c

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 52.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := c \cdot \left(a \cdot j - b \cdot z\right)\\ \mathbf{if}\;i \leq -1.5068808633695993 \cdot 10^{+134}:\\ \;\;\;\;\mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i\\ \mathbf{elif}\;i \leq -5.923366432227614 \cdot 10^{+25}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq -5.892184129782811 \cdot 10^{-125}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{elif}\;i \leq 1.5307096996046984 \cdot 10^{-285}:\\ \;\;\;\;\mathsf{fma}\left(-t, a \cdot x, \left(j \cdot c\right) \cdot a\right)\\ \mathbf{elif}\;i \leq 2.264825376384248 \cdot 10^{+54}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\left(b \cdot t - j \cdot y\right) \cdot i\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* c (- (* a j) (* b z)))))
  (if (<= i -1.5068808633695993e+134)
    (* (fma b t (- (* j y))) i)
    (if (<= i -5.923366432227614e+25)
      t_1
      (if (<= i -5.892184129782811e-125)
        (* x (- (* z y) (* a t)))
        (if (<= i 1.5307096996046984e-285)
          (fma (- t) (* a x) (* (* j c) a))
          (if (<= i 2.264825376384248e+54)
            t_1
            (* (- (* b t) (* j y)) 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 = c * ((a * j) - (b * z));
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = fma(b, t, -(j * y)) * i;
	} else if (i <= -5.923366432227614e+25) {
		tmp = t_1;
	} else if (i <= -5.892184129782811e-125) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 1.5307096996046984e-285) {
		tmp = fma(-t, (a * x), ((j * c) * a));
	} else if (i <= 2.264825376384248e+54) {
		tmp = t_1;
	} else {
		tmp = ((b * t) - (j * y)) * i;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(a * j) - Float64(b * z)))
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = Float64(fma(b, t, Float64(-Float64(j * y))) * i);
	elseif (i <= -5.923366432227614e+25)
		tmp = t_1;
	elseif (i <= -5.892184129782811e-125)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	elseif (i <= 1.5307096996046984e-285)
		tmp = fma(Float64(-t), Float64(a * x), Float64(Float64(j * c) * a));
	elseif (i <= 2.264825376384248e+54)
		tmp = t_1;
	else
		tmp = Float64(Float64(Float64(b * t) - Float64(j * y)) * i);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.5068808633695993e+134], N[(N[(b * t + (-N[(j * y), $MachinePrecision])), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, -5.923366432227614e+25], t$95$1, If[LessEqual[i, -5.892184129782811e-125], N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.5307096996046984e-285], N[((-t) * N[(a * x), $MachinePrecision] + N[(N[(j * c), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.264825376384248e+54], t$95$1, N[(N[(N[(b * t), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]]]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (c * ((a * j) - (b * z))) IN
		LET tmp_4 = IF (i <= (2264825376384247857310961182255050825308687741396975616)) THEN t_1 ELSE (((b * t) - (j * y)) * i) ENDIF IN
		LET tmp_3 = IF (i <= (15307096996046983737433145533008935886893309867568594722220177246754504456415515853509824246460536071983402343503091013014349658511075980024345937366414610293285600644130965471313873101726040222454288107860943169984514121134127747253366073680531440871560976426307370899541107231647504705614693663109215639215351956320659012145520863487889486775356299950630963115111245031068311862461806204247062437200939510802271806849024105875064218913726829558171882420114764763719903140188197299578001051896368227627070882998604590022050490644478153396223619795453607554284485370302550525420613672854128589081082910480049076459802789786511818611270295763194995146571239414698050463063856707623955344388377852737903594970703125e-997)) THEN (((- t) * (a * x)) + ((j * c) * a)) ELSE tmp_4 ENDIF IN
		LET tmp_2 = IF (i <= (-58921841297828113256330958373968817783874325959731883712872645899430548089259271090837819498682570384352099900602690400807160463411187371518347965618351571846998383082058910971195754430810265260163389273620025301355606349768074347641116317341491662994563020273678847386541059156385333897470285073019909127811644111716304905712604522705078125e-465)) THEN (x * ((z * y) - (a * t))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (i <= (-59233664322276144256647168)) THEN t_1 ELSE tmp_2 ENDIF IN
		LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN (((b * t) + (- (j * y))) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 5 regimes

2. if i < -1.5068808633695993e134

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
   7. Step-by-step derivation

   8. Applied rewrites 38.9%

      \[\leadsto \mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i \]

   if -1.5068808633695993e134 < i < -5.9233664322276144e25 or 1.5307096996046984e-285 < i < 2.2648253763842479e54

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   if -5.9233664322276144e25 < i < -5.8921841297828113e-125

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]

   if -5.8921841297828113e-125 < i < 1.5307096996046984e-285

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 36.7%

      \[\leadsto \mathsf{fma}\left(-t, a \cdot x, \left(j \cdot c\right) \cdot a\right) \]

   if 2.2648253763842479e54 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 11: 52.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \mathbf{if}\;i \leq -1.5068808633695993 \cdot 10^{+134}:\\ \;\;\;\;\mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i\\ \mathbf{elif}\;i \leq -5.923366432227614 \cdot 10^{+25}:\\ \;\;\;\;c \cdot \left(a \cdot j - b \cdot z\right)\\ \mathbf{elif}\;i \leq -1.1853604339590474 \cdot 10^{-123}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{elif}\;i \leq 1.6258191723730325 \cdot 10^{-13}:\\ \;\;\;\;a \cdot \mathsf{fma}\left(t, -x, j \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;\left(b \cdot t - j \cdot y\right) \cdot i\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= i -1.5068808633695993e+134)
  (* (fma b t (- (* j y))) i)
  (if (<= i -5.923366432227614e+25)
    (* c (- (* a j) (* b z)))
    (if (<= i -1.1853604339590474e-123)
      (* x (- (* z y) (* a t)))
      (if (<= i 1.6258191723730325e-13)
        (* a (fma t (- x) (* j c)))
        (* (- (* b t) (* j y)) 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.5068808633695993e+134) {
		tmp = fma(b, t, -(j * y)) * i;
	} else if (i <= -5.923366432227614e+25) {
		tmp = c * ((a * j) - (b * z));
	} else if (i <= -1.1853604339590474e-123) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 1.6258191723730325e-13) {
		tmp = a * fma(t, -x, (j * c));
	} else {
		tmp = ((b * t) - (j * y)) * i;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = Float64(fma(b, t, Float64(-Float64(j * y))) * i);
	elseif (i <= -5.923366432227614e+25)
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	elseif (i <= -1.1853604339590474e-123)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	elseif (i <= 1.6258191723730325e-13)
		tmp = Float64(a * fma(t, Float64(-x), Float64(j * c)));
	else
		tmp = Float64(Float64(Float64(b * t) - Float64(j * y)) * i);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.5068808633695993e+134], N[(N[(b * t + (-N[(j * y), $MachinePrecision])), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, -5.923366432227614e+25], N[(c * N[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.1853604339590474e-123], N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.6258191723730325e-13], N[(a * N[(t * (-x) + N[(j * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * t), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET tmp_3 = IF (i <= (162581917237303246126924679287141379245042183132596846917294897139072418212890625e-93)) THEN (a * ((t * (- x)) + (j * c))) ELSE (((b * t) - (j * y)) * i) ENDIF IN
	LET tmp_2 = IF (i <= (-11853604339590474183328513713063193523034499684923925742614326799966273006444797346732505637525515193870297825079654596703340955295770426738681477760460994901059787308123853790825460300915586537964273232646222980755479888850345785029840576809921523601481872564621331627459852079458104380916852959269858214241821769974194467067718505859375e-460)) THEN (x * ((z * y) - (a * t))) ELSE tmp_3 ENDIF IN
	LET tmp_1 = IF (i <= (-59233664322276144256647168)) THEN (c * ((a * j) - (b * z))) ELSE tmp_2 ENDIF IN
	LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN (((b * t) + (- (j * y))) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 5 regimes

2. if i < -1.5068808633695993e134

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
   7. Step-by-step derivation

   8. Applied rewrites 38.9%

      \[\leadsto \mathsf{fma}\left(b, t, -j \cdot y\right) \cdot i \]

   if -1.5068808633695993e134 < i < -5.9233664322276144e25

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   if -5.9233664322276144e25 < i < -1.1853604339590474e-123

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]

   if -1.1853604339590474e-123 < i < 1.6258191723730325e-13

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 39.6%

      \[\leadsto a \cdot \mathsf{fma}\left(t, -x, j \cdot c\right) \]

   if 1.6258191723730325e-13 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 12: 51.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := \left(b \cdot t - j \cdot y\right) \cdot i\\ \mathbf{if}\;i \leq -1.5068808633695993 \cdot 10^{+134}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq -5.923366432227614 \cdot 10^{+25}:\\ \;\;\;\;c \cdot \left(a \cdot j - b \cdot z\right)\\ \mathbf{elif}\;i \leq -1.1853604339590474 \cdot 10^{-123}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{elif}\;i \leq 1.6258191723730325 \cdot 10^{-13}:\\ \;\;\;\;a \cdot \mathsf{fma}\left(t, -x, j \cdot c\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- (* b t) (* j y)) i)))
  (if (<= i -1.5068808633695993e+134)
    t_1
    (if (<= i -5.923366432227614e+25)
      (* c (- (* a j) (* b z)))
      (if (<= i -1.1853604339590474e-123)
        (* x (- (* z y) (* a t)))
        (if (<= i 1.6258191723730325e-13)
          (* a (fma t (- x) (* j c)))
          t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = ((b * t) - (j * y)) * i;
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_1;
	} else if (i <= -5.923366432227614e+25) {
		tmp = c * ((a * j) - (b * z));
	} else if (i <= -1.1853604339590474e-123) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 1.6258191723730325e-13) {
		tmp = a * fma(t, -x, (j * c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(Float64(b * t) - Float64(j * y)) * i)
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = t_1;
	elseif (i <= -5.923366432227614e+25)
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	elseif (i <= -1.1853604339590474e-123)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	elseif (i <= 1.6258191723730325e-13)
		tmp = Float64(a * fma(t, Float64(-x), Float64(j * c)));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (((b * t) - (j * y)) * i) IN
		LET tmp_3 = IF (i <= (162581917237303246126924679287141379245042183132596846917294897139072418212890625e-93)) THEN (a * ((t * (- x)) + (j * c))) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (i <= (-11853604339590474183328513713063193523034499684923925742614326799966273006444797346732505637525515193870297825079654596703340955295770426738681477760460994901059787308123853790825460300915586537964273232646222980755479888850345785029840576809921523601481872564621331627459852079458104380916852959269858214241821769974194467067718505859375e-460)) THEN (x * ((z * y) - (a * t))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (i <= (-59233664322276144256647168)) THEN (c * ((a * j) - (b * z))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if i < -1.5068808633695993e134 or 1.6258191723730325e-13 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]

   if -1.5068808633695993e134 < i < -5.9233664322276144e25

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   if -5.9233664322276144e25 < i < -1.1853604339590474e-123

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]

   if -1.1853604339590474e-123 < i < 1.6258191723730325e-13

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 39.6%

      \[\leadsto a \cdot \mathsf{fma}\left(t, -x, j \cdot c\right) \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 13: 51.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := \left(b \cdot t - j \cdot y\right) \cdot i\\ \mathbf{if}\;i \leq -1.5068808633695993 \cdot 10^{+134}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq -5.923366432227614 \cdot 10^{+25}:\\ \;\;\;\;c \cdot \left(a \cdot j - b \cdot z\right)\\ \mathbf{elif}\;i \leq -1.1853604339590474 \cdot 10^{-123}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{elif}\;i \leq 1.6258191723730325 \cdot 10^{-13}:\\ \;\;\;\;\left(j \cdot c - t \cdot x\right) \cdot a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- (* b t) (* j y)) i)))
  (if (<= i -1.5068808633695993e+134)
    t_1
    (if (<= i -5.923366432227614e+25)
      (* c (- (* a j) (* b z)))
      (if (<= i -1.1853604339590474e-123)
        (* x (- (* z y) (* a t)))
        (if (<= i 1.6258191723730325e-13)
          (* (- (* j c) (* t x)) 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 = ((b * t) - (j * y)) * i;
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_1;
	} else if (i <= -5.923366432227614e+25) {
		tmp = c * ((a * j) - (b * z));
	} else if (i <= -1.1853604339590474e-123) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 1.6258191723730325e-13) {
		tmp = ((j * c) - (t * x)) * a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 * t) - (j * y)) * i
    if (i <= (-1.5068808633695993d+134)) then
        tmp = t_1
    else if (i <= (-5.923366432227614d+25)) then
        tmp = c * ((a * j) - (b * z))
    else if (i <= (-1.1853604339590474d-123)) then
        tmp = x * ((z * y) - (a * t))
    else if (i <= 1.6258191723730325d-13) then
        tmp = ((j * c) - (t * x)) * 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 = ((b * t) - (j * y)) * i;
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_1;
	} else if (i <= -5.923366432227614e+25) {
		tmp = c * ((a * j) - (b * z));
	} else if (i <= -1.1853604339590474e-123) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 1.6258191723730325e-13) {
		tmp = ((j * c) - (t * x)) * a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = ((b * t) - (j * y)) * i
	tmp = 0
	if i <= -1.5068808633695993e+134:
		tmp = t_1
	elif i <= -5.923366432227614e+25:
		tmp = c * ((a * j) - (b * z))
	elif i <= -1.1853604339590474e-123:
		tmp = x * ((z * y) - (a * t))
	elif i <= 1.6258191723730325e-13:
		tmp = ((j * c) - (t * x)) * a
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(Float64(b * t) - Float64(j * y)) * i)
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = t_1;
	elseif (i <= -5.923366432227614e+25)
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	elseif (i <= -1.1853604339590474e-123)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	elseif (i <= 1.6258191723730325e-13)
		tmp = Float64(Float64(Float64(j * c) - Float64(t * x)) * 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 = ((b * t) - (j * y)) * i;
	tmp = 0.0;
	if (i <= -1.5068808633695993e+134)
		tmp = t_1;
	elseif (i <= -5.923366432227614e+25)
		tmp = c * ((a * j) - (b * z));
	elseif (i <= -1.1853604339590474e-123)
		tmp = x * ((z * y) - (a * t));
	elseif (i <= 1.6258191723730325e-13)
		tmp = ((j * c) - (t * x)) * 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[(b * t), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -1.5068808633695993e+134], t$95$1, If[LessEqual[i, -5.923366432227614e+25], N[(c * N[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.1853604339590474e-123], N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.6258191723730325e-13], N[(N[(N[(j * c), $MachinePrecision] - N[(t * x), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (((b * t) - (j * y)) * i) IN
		LET tmp_3 = IF (i <= (162581917237303246126924679287141379245042183132596846917294897139072418212890625e-93)) THEN (((j * c) - (t * x)) * a) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (i <= (-11853604339590474183328513713063193523034499684923925742614326799966273006444797346732505637525515193870297825079654596703340955295770426738681477760460994901059787308123853790825460300915586537964273232646222980755479888850345785029840576809921523601481872564621331627459852079458104380916852959269858214241821769974194467067718505859375e-460)) THEN (x * ((z * y) - (a * t))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (i <= (-59233664322276144256647168)) THEN (c * ((a * j) - (b * z))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if i < -1.5068808633695993e134 or 1.6258191723730325e-13 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]

   if -1.5068808633695993e134 < i < -5.9233664322276144e25

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   if -5.9233664322276144e25 < i < -1.1853604339590474e-123

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]

   if -1.1853604339590474e-123 < i < 1.6258191723730325e-13

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]

   6. Applied rewrites 39.2%

      \[\leadsto \left(j \cdot c - t \cdot x\right) \cdot a \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 14: 50.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := c \cdot \left(a \cdot j - b \cdot z\right)\\ t_2 := \left(b \cdot t - j \cdot y\right) \cdot i\\ \mathbf{if}\;i \leq -1.5068808633695993 \cdot 10^{+134}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;i \leq -5.923366432227614 \cdot 10^{+25}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq 1.5307096996046984 \cdot 10^{-285}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{elif}\;i \leq 2.264825376384248 \cdot 10^{+54}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* c (- (* a j) (* b z))))
       (t_2 (* (- (* b t) (* j y)) i)))
  (if (<= i -1.5068808633695993e+134)
    t_2
    (if (<= i -5.923366432227614e+25)
      t_1
      (if (<= i 1.5307096996046984e-285)
        (* x (- (* z y) (* a t)))
        (if (<= i 2.264825376384248e+54) 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 * ((a * j) - (b * z));
	double t_2 = ((b * t) - (j * y)) * i;
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_2;
	} else if (i <= -5.923366432227614e+25) {
		tmp = t_1;
	} else if (i <= 1.5307096996046984e-285) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 2.264825376384248e+54) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 * ((a * j) - (b * z))
    t_2 = ((b * t) - (j * y)) * i
    if (i <= (-1.5068808633695993d+134)) then
        tmp = t_2
    else if (i <= (-5.923366432227614d+25)) then
        tmp = t_1
    else if (i <= 1.5307096996046984d-285) then
        tmp = x * ((z * y) - (a * t))
    else if (i <= 2.264825376384248d+54) 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 * ((a * j) - (b * z));
	double t_2 = ((b * t) - (j * y)) * i;
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_2;
	} else if (i <= -5.923366432227614e+25) {
		tmp = t_1;
	} else if (i <= 1.5307096996046984e-285) {
		tmp = x * ((z * y) - (a * t));
	} else if (i <= 2.264825376384248e+54) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((a * j) - (b * z))
	t_2 = ((b * t) - (j * y)) * i
	tmp = 0
	if i <= -1.5068808633695993e+134:
		tmp = t_2
	elif i <= -5.923366432227614e+25:
		tmp = t_1
	elif i <= 1.5307096996046984e-285:
		tmp = x * ((z * y) - (a * t))
	elif i <= 2.264825376384248e+54:
		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(Float64(a * j) - Float64(b * z)))
	t_2 = Float64(Float64(Float64(b * t) - Float64(j * y)) * i)
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = t_2;
	elseif (i <= -5.923366432227614e+25)
		tmp = t_1;
	elseif (i <= 1.5307096996046984e-285)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	elseif (i <= 2.264825376384248e+54)
		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 * ((a * j) - (b * z));
	t_2 = ((b * t) - (j * y)) * i;
	tmp = 0.0;
	if (i <= -1.5068808633695993e+134)
		tmp = t_2;
	elseif (i <= -5.923366432227614e+25)
		tmp = t_1;
	elseif (i <= 1.5307096996046984e-285)
		tmp = x * ((z * y) - (a * t));
	elseif (i <= 2.264825376384248e+54)
		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[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(b * t), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -1.5068808633695993e+134], t$95$2, If[LessEqual[i, -5.923366432227614e+25], t$95$1, If[LessEqual[i, 1.5307096996046984e-285], N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.264825376384248e+54], t$95$1, t$95$2]]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (c * ((a * j) - (b * z))) IN
		LET t_2 = (((b * t) - (j * y)) * i) IN
			LET tmp_3 = IF (i <= (2264825376384247857310961182255050825308687741396975616)) THEN t_1 ELSE t_2 ENDIF IN
			LET tmp_2 = IF (i <= (15307096996046983737433145533008935886893309867568594722220177246754504456415515853509824246460536071983402343503091013014349658511075980024345937366414610293285600644130965471313873101726040222454288107860943169984514121134127747253366073680531440871560976426307370899541107231647504705614693663109215639215351956320659012145520863487889486775356299950630963115111245031068311862461806204247062437200939510802271806849024105875064218913726829558171882420114764763719903140188197299578001051896368227627070882998604590022050490644478153396223619795453607554284485370302550525420613672854128589081082910480049076459802789786511818611270295763194995146571239414698050463063856707623955344388377852737903594970703125e-997)) THEN (x * ((z * y) - (a * t))) ELSE tmp_3 ENDIF IN
			LET tmp_1 = IF (i <= (-59233664322276144256647168)) THEN t_1 ELSE tmp_2 ENDIF IN
			LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN t_2 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if i < -1.5068808633695993e134 or 2.2648253763842479e54 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]

   if -1.5068808633695993e134 < i < -5.9233664322276144e25 or 1.5307096996046984e-285 < i < 2.2648253763842479e54

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   if -5.9233664322276144e25 < i < 1.5307096996046984e-285

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 15: 50.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := j \cdot \left(a \cdot c - i \cdot y\right)\\ \mathbf{if}\;j \leq -6.29579328475263 \cdot 10^{+64}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 1.1988935733946621 \cdot 10^{-188}:\\ \;\;\;\;t \cdot \left(b \cdot i - a \cdot x\right)\\ \mathbf{elif}\;j \leq 1.1472753144989379 \cdot 10^{-127}:\\ \;\;\;\;z \cdot \left(y \cdot x - c \cdot b\right)\\ \mathbf{elif}\;j \leq 1.995613904459009 \cdot 10^{+70}:\\ \;\;\;\;x \cdot \left(z \cdot y - a \cdot t\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* j (- (* a c) (* i y)))))
  (if (<= j -6.29579328475263e+64)
    t_1
    (if (<= j 1.1988935733946621e-188)
      (* t (- (* b i) (* a x)))
      (if (<= j 1.1472753144989379e-127)
        (* z (- (* y x) (* c b)))
        (if (<= j 1.995613904459009e+70)
          (* x (- (* z y) (* a t)))
          t_1))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((a * c) - (i * y));
	double tmp;
	if (j <= -6.29579328475263e+64) {
		tmp = t_1;
	} else if (j <= 1.1988935733946621e-188) {
		tmp = t * ((b * i) - (a * x));
	} else if (j <= 1.1472753144989379e-127) {
		tmp = z * ((y * x) - (c * b));
	} else if (j <= 1.995613904459009e+70) {
		tmp = x * ((z * y) - (a * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = j * ((a * c) - (i * y))
    if (j <= (-6.29579328475263d+64)) then
        tmp = t_1
    else if (j <= 1.1988935733946621d-188) then
        tmp = t * ((b * i) - (a * x))
    else if (j <= 1.1472753144989379d-127) then
        tmp = z * ((y * x) - (c * b))
    else if (j <= 1.995613904459009d+70) then
        tmp = x * ((z * y) - (a * t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((a * c) - (i * y));
	double tmp;
	if (j <= -6.29579328475263e+64) {
		tmp = t_1;
	} else if (j <= 1.1988935733946621e-188) {
		tmp = t * ((b * i) - (a * x));
	} else if (j <= 1.1472753144989379e-127) {
		tmp = z * ((y * x) - (c * b));
	} else if (j <= 1.995613904459009e+70) {
		tmp = x * ((z * y) - (a * t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((a * c) - (i * y))
	tmp = 0
	if j <= -6.29579328475263e+64:
		tmp = t_1
	elif j <= 1.1988935733946621e-188:
		tmp = t * ((b * i) - (a * x))
	elif j <= 1.1472753144989379e-127:
		tmp = z * ((y * x) - (c * b))
	elif j <= 1.995613904459009e+70:
		tmp = x * ((z * y) - (a * t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(a * c) - Float64(i * y)))
	tmp = 0.0
	if (j <= -6.29579328475263e+64)
		tmp = t_1;
	elseif (j <= 1.1988935733946621e-188)
		tmp = Float64(t * Float64(Float64(b * i) - Float64(a * x)));
	elseif (j <= 1.1472753144989379e-127)
		tmp = Float64(z * Float64(Float64(y * x) - Float64(c * b)));
	elseif (j <= 1.995613904459009e+70)
		tmp = Float64(x * Float64(Float64(z * y) - Float64(a * t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((a * c) - (i * y));
	tmp = 0.0;
	if (j <= -6.29579328475263e+64)
		tmp = t_1;
	elseif (j <= 1.1988935733946621e-188)
		tmp = t * ((b * i) - (a * x));
	elseif (j <= 1.1472753144989379e-127)
		tmp = z * ((y * x) - (c * b));
	elseif (j <= 1.995613904459009e+70)
		tmp = x * ((z * y) - (a * t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(a * c), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -6.29579328475263e+64], t$95$1, If[LessEqual[j, 1.1988935733946621e-188], N[(t * N[(N[(b * i), $MachinePrecision] - N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.1472753144989379e-127], N[(z * N[(N[(y * x), $MachinePrecision] - N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.995613904459009e+70], N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (j * ((a * c) - (i * y))) IN
		LET tmp_3 = IF (j <= (19956139044590089884235873713932106008184628700846438777137286141181952)) THEN (x * ((z * y) - (a * t))) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (j <= (114727531449893787036834113157161256835122667919576753151236192981819232095904135654426537152718095874285631240362929878499360203604301846542914597586470770624150157684769725740167086284096924353569877792971804163177894224178510402347157296731118679011894792833630696564222920287488369426905668566581196314568824590196527424268424510955810546875e-471)) THEN (z * ((y * x) - (c * b))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (j <= (1198893573394662115982026985758818429661271283013236594503881183081064834109304681737986560402364385391675031534272652584031496899356217993331440210964017288436332333543883036257141686474370959228750337372084864774929862300232201451942902672117355693644439775192994349496072681152947086359592449725609456357911985879055444393539791534055264041833685999695326177326735806234132200461669173993077928955973676377378735572942000729796637645952869758608251571363467746778042055666446685791015625e-677)) THEN (t * ((b * i) - (a * x))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (j <= (-62957932847526303653361918068401372873861277536829928449115160576)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if j < -6.2957932847526304e64 or 1.995613904459009e70 < j

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   5. Taylor expanded in x around 0

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 39.0%

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]

   if -6.2957932847526304e64 < j < 1.1988935733946621e-188

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in t around inf

      \[\leadsto t \cdot \left(b \cdot i - a \cdot x\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.0%

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

   if 1.1988935733946621e-188 < j < 1.1472753144989379e-127

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in z around -inf

      \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c - x \cdot y\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.6%

      \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c - x \cdot y\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.6%

       \[\leadsto z \cdot \left(y \cdot x - c \cdot b\right) \]

   if 1.1472753144989379e-127 < j < 1.995613904459009e70

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   10. Step-by-step derivation

   11. Applied rewrites 39.8%

       \[\leadsto x \cdot \left(z \cdot y - a \cdot t\right) \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 16: 50.4% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* t (- (* b i) (* a x)))))
  (if (<= t -5.881354984324333e+112)
    t_1
    (if (<= t 4.321062839219051e+94) (* j (- (* a c) (* i y))) t_1))))

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 = t * ((b * i) - (a * x))
    if (t <= (-5.881354984324333d+112)) then
        tmp = t_1
    else if (t <= 4.321062839219051d+94) then
        tmp = j * ((a * c) - (i * y))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (t * ((b * i) - (a * x))) IN
		LET tmp_1 = IF (t <= (43210628392190507493955542397247136843294690070887094512136488627766935582293990174101266759680)) THEN (j * ((a * c) - (i * y))) ELSE t_1 ENDIF IN
		LET tmp = IF (t <= (-58813549843243333087610052959426559324974984931981634348698937303961760215747868627457527881231509091705512001536)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -5.8813549843243333e112 or 4.3210628392190507e94 < t

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in t around inf

      \[\leadsto t \cdot \left(b \cdot i - a \cdot x\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.0%

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

   if -5.8813549843243333e112 < t < 4.3210628392190507e94

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   5. Taylor expanded in x around 0

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 39.0%

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 44.4% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* j (- (* a c) (* i y)))))
  (if (<= i -1.5068808633695993e+134)
    t_1
    (if (<= i 4.019337884354797e-18) (* c (- (* a j) (* b 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 = j * ((a * c) - (i * y));
	double tmp;
	if (i <= -1.5068808633695993e+134) {
		tmp = t_1;
	} else if (i <= 4.019337884354797e-18) {
		tmp = c * ((a * j) - (b * z));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = j * ((a * c) - (i * y))
    if (i <= (-1.5068808633695993d+134)) then
        tmp = t_1
    else if (i <= 4.019337884354797d-18) then
        tmp = c * ((a * j) - (b * z))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

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

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(a * c) - Float64(i * y)))
	tmp = 0.0
	if (i <= -1.5068808633695993e+134)
		tmp = t_1;
	elseif (i <= 4.019337884354797e-18)
		tmp = Float64(c * Float64(Float64(a * j) - Float64(b * z)));
	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 * ((a * c) - (i * y));
	tmp = 0.0;
	if (i <= -1.5068808633695993e+134)
		tmp = t_1;
	elseif (i <= 4.019337884354797e-18)
		tmp = c * ((a * j) - (b * z));
	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[(a * c), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.5068808633695993e+134], t$95$1, If[LessEqual[i, 4.019337884354797e-18], N[(c * N[(N[(a * j), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (j * ((a * c) - (i * y))) IN
		LET tmp_1 = IF (i <= (40193378843547968518420449865122032271053311247121890559252932462186436168849468231201171875e-109)) THEN (c * ((a * j) - (b * z))) ELSE t_1 ENDIF IN
		LET tmp = IF (i <= (-150688086336959925292050515762858345343299814900140664345531915438758097351695209249594554049272034060826524552385543265955385591201792)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if i < -1.5068808633695993e134 or 4.0193378843547969e-18 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   5. Taylor expanded in x around 0

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 39.0%

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]

   if -1.5068808633695993e134 < i < 4.0193378843547969e-18

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 42.1% accurate, 1.7× speedup

Math

\[\begin{array}{l} t_1 := j \cdot \left(a \cdot c - i \cdot y\right)\\ \mathbf{if}\;j \leq -1.5069751265434715 \cdot 10^{-76}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 1.3258539151952176 \cdot 10^{-286}:\\ \;\;\;\;t \cdot \left(-1 \cdot \left(a \cdot x\right)\right)\\ \mathbf{elif}\;j \leq 9.247028734412017 \cdot 10^{-143}:\\ \;\;\;\;-1 \cdot \left(z \cdot \left(b \cdot c\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* j (- (* a c) (* i y)))))
  (if (<= j -1.5069751265434715e-76)
    t_1
    (if (<= j 1.3258539151952176e-286)
      (* t (* -1.0 (* a x)))
      (if (<= j 9.247028734412017e-143) (* -1.0 (* z (* b c))) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((a * c) - (i * y));
	double tmp;
	if (j <= -1.5069751265434715e-76) {
		tmp = t_1;
	} else if (j <= 1.3258539151952176e-286) {
		tmp = t * (-1.0 * (a * x));
	} else if (j <= 9.247028734412017e-143) {
		tmp = -1.0 * (z * (b * c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = j * ((a * c) - (i * y))
    if (j <= (-1.5069751265434715d-76)) then
        tmp = t_1
    else if (j <= 1.3258539151952176d-286) then
        tmp = t * ((-1.0d0) * (a * x))
    else if (j <= 9.247028734412017d-143) then
        tmp = (-1.0d0) * (z * (b * c))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((a * c) - (i * y));
	double tmp;
	if (j <= -1.5069751265434715e-76) {
		tmp = t_1;
	} else if (j <= 1.3258539151952176e-286) {
		tmp = t * (-1.0 * (a * x));
	} else if (j <= 9.247028734412017e-143) {
		tmp = -1.0 * (z * (b * c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((a * c) - (i * y))
	tmp = 0
	if j <= -1.5069751265434715e-76:
		tmp = t_1
	elif j <= 1.3258539151952176e-286:
		tmp = t * (-1.0 * (a * x))
	elif j <= 9.247028734412017e-143:
		tmp = -1.0 * (z * (b * c))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(a * c) - Float64(i * y)))
	tmp = 0.0
	if (j <= -1.5069751265434715e-76)
		tmp = t_1;
	elseif (j <= 1.3258539151952176e-286)
		tmp = Float64(t * Float64(-1.0 * Float64(a * x)));
	elseif (j <= 9.247028734412017e-143)
		tmp = Float64(-1.0 * Float64(z * Float64(b * c)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = j * ((a * c) - (i * y));
	tmp = 0.0;
	if (j <= -1.5069751265434715e-76)
		tmp = t_1;
	elseif (j <= 1.3258539151952176e-286)
		tmp = t * (-1.0 * (a * x));
	elseif (j <= 9.247028734412017e-143)
		tmp = -1.0 * (z * (b * c));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(a * c), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.5069751265434715e-76], t$95$1, If[LessEqual[j, 1.3258539151952176e-286], N[(t * N[(-1.0 * N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 9.247028734412017e-143], N[(-1.0 * N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (j * ((a * c) - (i * y))) IN
		LET tmp_2 = IF (j <= (924702873441201662636754244069287354398584835131637175084806480193372235127325576125938188688606553758501924238504236501852850072550705160976715116785626440207613396503391736955110358027310123394799207003138910687912365695847992402657238775718644871079550953583580756434763379942548691256494733079217721381212445292158588665200224502002169547909549152109320857562124729156494140625e-523)) THEN ((-1) * (z * (b * c))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (j <= (1325853915195217599635768932590191142379976774787956916813860079746537014725303164041435521742677306207792313525621336777128817492115173865892002443434592732737322879334021464826083883067966895040235608666904254016976014945759230301696394702729457351218328991480662003122080191907348011269564921435879856451671921584340928682634585902970221231379535458507125560255000177682935145120830506419212009314477198433808042633248188898238607618858518026860025865950543634660090024600427448567118948832104622457492730934290854352015942450458836736518628009560150104765592434696806203800659293059163135370606503554476734279736253727300229409500945845666553602633738756949384639117323590740138428145655780099332332611083984375e-1000)) THEN (t * ((-1) * (a * x))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (j <= (-150697512654347153160861923004104846826400688534141735543494083093235750840404666687245823275352517176536860925220219334952157122358133983277853776110019540907121707079853437343463793741428491390621502432622946798801422119140625e-303)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if j < -1.5069751265434715e-76 or 9.2470287344120166e-143 < j

   1. Initial program 73.5%

      \[\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. Taylor expanded in b around 0

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

   4. Applied rewrites 61.2%

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

   5. Taylor expanded in x around 0

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 39.0%

      \[\leadsto j \cdot \left(a \cdot c - i \cdot y\right) \]

   if -1.5069751265434715e-76 < j < 1.3258539151952176e-286

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in t around inf

      \[\leadsto t \cdot \left(b \cdot i - a \cdot x\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.0%

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

   10. Taylor expanded in x around inf

       \[\leadsto t \cdot \left(-1 \cdot \left(a \cdot x\right)\right) \]
   11. Step-by-step derivation

   12. Applied rewrites 22.2%

       \[\leadsto t \cdot \left(-1 \cdot \left(a \cdot x\right)\right) \]

   if 1.3258539151952176e-286 < j < 9.2470287344120166e-143

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in z around -inf

      \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c - x \cdot y\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.6%

      \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c - x \cdot y\right)\right) \]

   10. Taylor expanded in x around 0

       \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c\right)\right) \]
   11. Step-by-step derivation

   12. Applied rewrites 22.1%

       \[\leadsto -1 \cdot \left(z \cdot \left(b \cdot c\right)\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 19: 30.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} t_1 := \left(-b \cdot z\right) \cdot c\\ \mathbf{if}\;c \leq -3.214420886891082 \cdot 10^{+120}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq -0.01521215292682115:\\ \;\;\;\;a \cdot \left(c \cdot j\right)\\ \mathbf{elif}\;c \leq 1.3062611628009748 \cdot 10^{-20}:\\ \;\;\;\;-j \cdot \left(i \cdot y\right)\\ \mathbf{elif}\;c \leq 1.8631924830714108 \cdot 10^{+175}:\\ \;\;\;\;c \cdot \left(a \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (- (* b z)) c)))
  (if (<= c -3.214420886891082e+120)
    t_1
    (if (<= c -0.01521215292682115)
      (* a (* c j))
      (if (<= c 1.3062611628009748e-20)
        (- (* j (* i y)))
        (if (<= c 1.8631924830714108e+175) (* c (* a 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 * z) * c;
	double tmp;
	if (c <= -3.214420886891082e+120) {
		tmp = t_1;
	} else if (c <= -0.01521215292682115) {
		tmp = a * (c * j);
	} else if (c <= 1.3062611628009748e-20) {
		tmp = -(j * (i * y));
	} else if (c <= 1.8631924830714108e+175) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 * z) * c
    if (c <= (-3.214420886891082d+120)) then
        tmp = t_1
    else if (c <= (-0.01521215292682115d0)) then
        tmp = a * (c * j)
    else if (c <= 1.3062611628009748d-20) then
        tmp = -(j * (i * y))
    else if (c <= 1.8631924830714108d+175) then
        tmp = c * (a * 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 * z) * c;
	double tmp;
	if (c <= -3.214420886891082e+120) {
		tmp = t_1;
	} else if (c <= -0.01521215292682115) {
		tmp = a * (c * j);
	} else if (c <= 1.3062611628009748e-20) {
		tmp = -(j * (i * y));
	} else if (c <= 1.8631924830714108e+175) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = -(b * z) * c
	tmp = 0
	if c <= -3.214420886891082e+120:
		tmp = t_1
	elif c <= -0.01521215292682115:
		tmp = a * (c * j)
	elif c <= 1.3062611628009748e-20:
		tmp = -(j * (i * y))
	elif c <= 1.8631924830714108e+175:
		tmp = c * (a * j)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(-Float64(b * z)) * c)
	tmp = 0.0
	if (c <= -3.214420886891082e+120)
		tmp = t_1;
	elseif (c <= -0.01521215292682115)
		tmp = Float64(a * Float64(c * j));
	elseif (c <= 1.3062611628009748e-20)
		tmp = Float64(-Float64(j * Float64(i * y)));
	elseif (c <= 1.8631924830714108e+175)
		tmp = Float64(c * Float64(a * 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 * z) * c;
	tmp = 0.0;
	if (c <= -3.214420886891082e+120)
		tmp = t_1;
	elseif (c <= -0.01521215292682115)
		tmp = a * (c * j);
	elseif (c <= 1.3062611628009748e-20)
		tmp = -(j * (i * y));
	elseif (c <= 1.8631924830714108e+175)
		tmp = c * (a * 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[((-N[(b * z), $MachinePrecision]) * c), $MachinePrecision]}, If[LessEqual[c, -3.214420886891082e+120], t$95$1, If[LessEqual[c, -0.01521215292682115], N[(a * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.3062611628009748e-20], (-N[(j * N[(i * y), $MachinePrecision]), $MachinePrecision]), If[LessEqual[c, 1.8631924830714108e+175], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = ((- (b * z)) * c) IN
		LET tmp_3 = IF (c <= (18631924830714108001886171562029931502404229276794157262372238796790777354728009286921955988907742414166472918425106371026390232253583082371472022280269109551954283740386033664)) THEN (c * (a * j)) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (c <= (1306261162800974771193959741653469315720724586263754439150429342841874813530012033879756927490234375e-119)) THEN (- (j * (i * y))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (c <= (-152121529268211506946695266151436953805387020111083984375e-58)) THEN (a * (c * j)) ELSE tmp_2 ENDIF IN
		LET tmp = IF (c <= (-3214420886891082210686238959829315320329144943508782895984018223925776522004556478824252172490691006579246419593463332864)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if c < -3.2144208868910822e120 or 1.8631924830714108e175 < c

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   5. Taylor expanded in z around inf

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

   7. Applied rewrites 21.7%

      \[\leadsto c \cdot \left(-1 \cdot \left(b \cdot z\right)\right) \]

   9. Applied rewrites 21.7%

      \[\leadsto \left(-b \cdot z\right) \cdot c \]

   if -3.2144208868910822e120 < c < -0.015212152926821151

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]

   5. Taylor expanded in x around 0

      \[\leadsto a \cdot \left(c \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.5%

      \[\leadsto a \cdot \left(c \cdot j\right) \]

   if -0.015212152926821151 < c < 1.3062611628009748e-20

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   5. Taylor expanded in y around inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 21.8%

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]

   9. Applied rewrites 21.8%

      \[\leadsto -\left(j \cdot y\right) \cdot i \]
   10. Step-by-step derivation

   11. Applied rewrites 21.9%

       \[\leadsto -j \cdot \left(i \cdot y\right) \]

   if 1.3062611628009748e-20 < c < 1.8631924830714108e175

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   5. Taylor expanded in z around 0

      \[\leadsto c \cdot \left(a \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.3%

      \[\leadsto c \cdot \left(a \cdot j\right) \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 20: 30.0% accurate, 2.1× speedup

Math

\[\begin{array}{l} t_1 := -j \cdot \left(i \cdot y\right)\\ \mathbf{if}\;i \leq -2.7610252601949285 \cdot 10^{+85}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq 1.432174943600374 \cdot 10^{-147}:\\ \;\;\;\;-1 \cdot \left(x \cdot \left(a \cdot t\right)\right)\\ \mathbf{elif}\;i \leq 2.5462571461224333 \cdot 10^{+20}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* j (* i y)))))
  (if (<= i -2.7610252601949285e+85)
    t_1
    (if (<= i 1.432174943600374e-147)
      (* -1.0 (* x (* a t)))
      (if (<= i 2.5462571461224333e+20) (* 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 = -(j * (i * y));
	double tmp;
	if (i <= -2.7610252601949285e+85) {
		tmp = t_1;
	} else if (i <= 1.432174943600374e-147) {
		tmp = -1.0 * (x * (a * t));
	} else if (i <= 2.5462571461224333e+20) {
		tmp = x * (y * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -(j * (i * y))
    if (i <= (-2.7610252601949285d+85)) then
        tmp = t_1
    else if (i <= 1.432174943600374d-147) then
        tmp = (-1.0d0) * (x * (a * t))
    else if (i <= 2.5462571461224333d+20) then
        tmp = x * (y * z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = -(j * (i * y));
	double tmp;
	if (i <= -2.7610252601949285e+85) {
		tmp = t_1;
	} else if (i <= 1.432174943600374e-147) {
		tmp = -1.0 * (x * (a * t));
	} else if (i <= 2.5462571461224333e+20) {
		tmp = x * (y * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = -(j * (i * y))
	tmp = 0
	if i <= -2.7610252601949285e+85:
		tmp = t_1
	elif i <= 1.432174943600374e-147:
		tmp = -1.0 * (x * (a * t))
	elif i <= 2.5462571461224333e+20:
		tmp = x * (y * z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(-Float64(j * Float64(i * y)))
	tmp = 0.0
	if (i <= -2.7610252601949285e+85)
		tmp = t_1;
	elseif (i <= 1.432174943600374e-147)
		tmp = Float64(-1.0 * Float64(x * Float64(a * t)));
	elseif (i <= 2.5462571461224333e+20)
		tmp = Float64(x * Float64(y * z));
	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 * (i * y));
	tmp = 0.0;
	if (i <= -2.7610252601949285e+85)
		tmp = t_1;
	elseif (i <= 1.432174943600374e-147)
		tmp = -1.0 * (x * (a * t));
	elseif (i <= 2.5462571461224333e+20)
		tmp = x * (y * z);
	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[(i * y), $MachinePrecision]), $MachinePrecision])}, If[LessEqual[i, -2.7610252601949285e+85], t$95$1, If[LessEqual[i, 1.432174943600374e-147], N[(-1.0 * N[(x * N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.5462571461224333e+20], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (- (j * (i * y))) IN
		LET tmp_2 = IF (i <= (254625714612243333120)) THEN (x * (y * z)) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (i <= (1432174943600373864172866149744863819531598683713141809128329604254995736982559429504128759454020845064745572953839281920621672614965320438962983432679651547772040973398563130944783317777817571456095977099539414804208923160243510240434188797866820175073814107958477740820926811653204656821270037421485425254737129844380086309163988849407952857596294381388457583881290702265687286853790283203125e-540)) THEN ((-1) * (x * (a * t))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (i <= (-27610252601949284780508835710665324127245118864166406554782818747958104751363328049152)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if i < -2.7610252601949285e85 or 254625714612243330000 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   5. Taylor expanded in y around inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 21.8%

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]

   9. Applied rewrites 21.8%

      \[\leadsto -\left(j \cdot y\right) \cdot i \]
   10. Step-by-step derivation

   11. Applied rewrites 21.9%

       \[\leadsto -j \cdot \left(i \cdot y\right) \]

   if -2.7610252601949285e85 < i < 1.4321749436003739e-147

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   6. Applied rewrites 39.6%

      \[\leadsto \left(z \cdot x - j \cdot i\right) \cdot y \]

   7. Taylor expanded in x around -inf

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 39.8%

      \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t - y \cdot z\right)\right) \]

   10. Taylor expanded in y around 0

       \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t\right)\right) \]
   11. Step-by-step derivation

   12. Applied rewrites 22.4%

       \[\leadsto -1 \cdot \left(x \cdot \left(a \cdot t\right)\right) \]

   if 1.4321749436003739e-147 < i < 254625714612243330000

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   5. Taylor expanded in x around inf

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

   7. Applied rewrites 22.9%

      \[\leadsto x \cdot \left(y \cdot z\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 21: 29.9% accurate, 2.6× speedup

Math

\[\begin{array}{l} t_1 := -j \cdot \left(i \cdot y\right)\\ \mathbf{if}\;i \leq -2.7610252601949285 \cdot 10^{+85}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq 1.0140676427305016 \cdot 10^{-13}:\\ \;\;\;\;\left(\left(-x\right) \cdot t\right) \cdot a\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* j (* i y)))))
  (if (<= i -2.7610252601949285e+85)
    t_1
    (if (<= i 1.0140676427305016e-13) (* (* (- x) 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 = -(j * (i * y));
	double tmp;
	if (i <= -2.7610252601949285e+85) {
		tmp = t_1;
	} else if (i <= 1.0140676427305016e-13) {
		tmp = (-x * t) * a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -(j * (i * y))
    if (i <= (-2.7610252601949285d+85)) then
        tmp = t_1
    else if (i <= 1.0140676427305016d-13) then
        tmp = (-x * 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 = -(j * (i * y));
	double tmp;
	if (i <= -2.7610252601949285e+85) {
		tmp = t_1;
	} else if (i <= 1.0140676427305016e-13) {
		tmp = (-x * t) * a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(-Float64(j * Float64(i * y)))
	tmp = 0.0
	if (i <= -2.7610252601949285e+85)
		tmp = t_1;
	elseif (i <= 1.0140676427305016e-13)
		tmp = Float64(Float64(Float64(-x) * 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 = -(j * (i * y));
	tmp = 0.0;
	if (i <= -2.7610252601949285e+85)
		tmp = t_1;
	elseif (i <= 1.0140676427305016e-13)
		tmp = (-x * 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[(j * N[(i * y), $MachinePrecision]), $MachinePrecision])}, If[LessEqual[i, -2.7610252601949285e+85], t$95$1, If[LessEqual[i, 1.0140676427305016e-13], N[(N[((-x) * t), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (- (j * (i * y))) IN
		LET tmp_1 = IF (i <= (101406764273050162940990597888560825098045771464061459710137569345533847808837890625e-96)) THEN (((- x) * t) * a) ELSE t_1 ENDIF IN
		LET tmp = IF (i <= (-27610252601949284780508835710665324127245118864166406554782818747958104751363328049152)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if i < -2.7610252601949285e85 or 1.0140676427305016e-13 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   5. Taylor expanded in y around inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 21.8%

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]

   9. Applied rewrites 21.8%

      \[\leadsto -\left(j \cdot y\right) \cdot i \]
   10. Step-by-step derivation

   11. Applied rewrites 21.9%

       \[\leadsto -j \cdot \left(i \cdot y\right) \]

   if -2.7610252601949285e85 < i < 1.0140676427305016e-13

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]

   5. Taylor expanded in x around inf

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

   7. Applied rewrites 22.5%

      \[\leadsto a \cdot \left(-1 \cdot \left(t \cdot x\right)\right) \]

   9. Applied rewrites 22.5%

      \[\leadsto \left(\left(-x\right) \cdot t\right) \cdot a \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 22: 29.7% accurate, 2.6× speedup

Math

\[\begin{array}{l} t_1 := -j \cdot \left(i \cdot y\right)\\ \mathbf{if}\;i \leq -3.10130950346649 \cdot 10^{+86}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq 2.081870728536461 \cdot 10^{+54}:\\ \;\;\;\;c \cdot \left(a \cdot j\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- (* j (* i y)))))
  (if (<= i -3.10130950346649e+86)
    t_1
    (if (<= i 2.081870728536461e+54) (* c (* a 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 = -(j * (i * y));
	double tmp;
	if (i <= -3.10130950346649e+86) {
		tmp = t_1;
	} else if (i <= 2.081870728536461e+54) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = -(j * (i * y))
    if (i <= (-3.10130950346649d+86)) then
        tmp = t_1
    else if (i <= 2.081870728536461d+54) then
        tmp = c * (a * 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 = -(j * (i * y));
	double tmp;
	if (i <= -3.10130950346649e+86) {
		tmp = t_1;
	} else if (i <= 2.081870728536461e+54) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(-Float64(j * Float64(i * y)))
	tmp = 0.0
	if (i <= -3.10130950346649e+86)
		tmp = t_1;
	elseif (i <= 2.081870728536461e+54)
		tmp = Float64(c * Float64(a * 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 = -(j * (i * y));
	tmp = 0.0;
	if (i <= -3.10130950346649e+86)
		tmp = t_1;
	elseif (i <= 2.081870728536461e+54)
		tmp = c * (a * 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[(j * N[(i * y), $MachinePrecision]), $MachinePrecision])}, If[LessEqual[i, -3.10130950346649e+86], t$95$1, If[LessEqual[i, 2.081870728536461e+54], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (- (j * (i * y))) IN
		LET tmp_1 = IF (i <= (2081870728536461027412590679537912746739934386821529600)) THEN (c * (a * j)) ELSE t_1 ENDIF IN
		LET tmp = IF (i <= (-310130950346649023310393935969600527424093274064620833001816139412678955680535557439488)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if i < -3.1013095034664902e86 or 2.081870728536461e54 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   5. Taylor expanded in y around inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 21.8%

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y\right)\right) \]

   9. Applied rewrites 21.8%

      \[\leadsto -\left(j \cdot y\right) \cdot i \]
   10. Step-by-step derivation

   11. Applied rewrites 21.9%

       \[\leadsto -j \cdot \left(i \cdot y\right) \]

   if -3.1013095034664902e86 < i < 2.081870728536461e54

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   5. Taylor expanded in z around 0

      \[\leadsto c \cdot \left(a \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.3%

      \[\leadsto c \cdot \left(a \cdot j\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 23: 29.7% accurate, 2.8× speedup

Math

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

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* b (* i t))))
  (if (<= i -8.300619316305329e+133)
    t_1
    (if (<= i 3.083873385286537e+62) (* c (* a 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 * (i * t);
	double tmp;
	if (i <= -8.300619316305329e+133) {
		tmp = t_1;
	} else if (i <= 3.083873385286537e+62) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    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 * (i * t)
    if (i <= (-8.300619316305329d+133)) then
        tmp = t_1
    else if (i <= 3.083873385286537d+62) then
        tmp = c * (a * 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 * (i * t);
	double tmp;
	if (i <= -8.300619316305329e+133) {
		tmp = t_1;
	} else if (i <= 3.083873385286537e+62) {
		tmp = c * (a * j);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(b * Float64(i * t))
	tmp = 0.0
	if (i <= -8.300619316305329e+133)
		tmp = t_1;
	elseif (i <= 3.083873385286537e+62)
		tmp = Float64(c * Float64(a * 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 * (i * t);
	tmp = 0.0;
	if (i <= -8.300619316305329e+133)
		tmp = t_1;
	elseif (i <= 3.083873385286537e+62)
		tmp = c * (a * 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[(i * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -8.300619316305329e+133], t$95$1, If[LessEqual[i, 3.083873385286537e+62], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (b * (i * t)) IN
		LET tmp_1 = IF (i <= (308387338528653687291245108036029331664853313400278027283202048)) THEN (c * (a * j)) ELSE t_1 ENDIF IN
		LET tmp = IF (i <= (-83006193163053291674449267909947670270806649700999519700672646568609024610452883690523705084446593485043271215043680248435925393080320)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if i < -8.3006193163053292e133 or 3.0838733852865369e62 < i

   1. Initial program 73.5%

      \[\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. Taylor expanded in i around -inf

      \[\leadsto -1 \cdot \left(i \cdot \left(j \cdot y - b \cdot t\right)\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.6%

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

   6. Applied rewrites 38.6%

      \[\leadsto \left(b \cdot t - j \cdot y\right) \cdot i \]

   7. Taylor expanded in y around 0

      \[\leadsto b \cdot \left(i \cdot t\right) \]
   8. Step-by-step derivation

   9. Applied rewrites 22.1%

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

   if -8.3006193163053292e133 < i < 3.0838733852865369e62

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   5. Taylor expanded in z around 0

      \[\leadsto c \cdot \left(a \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.3%

      \[\leadsto c \cdot \left(a \cdot j\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 24: 29.3% accurate, 2.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -4.22744243571953 \cdot 10^{-17}:\\ \;\;\;\;a \cdot \left(c \cdot j\right)\\ \mathbf{elif}\;c \leq 2.3744995975081357 \cdot 10^{-46}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;c \cdot \left(a \cdot j\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -4.22744243571953e-17)
  (* a (* c j))
  (if (<= c 2.3744995975081357e-46) (* x (* y z)) (* c (* a j)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -4.22744243571953e-17) {
		tmp = a * (c * j);
	} else if (c <= 2.3744995975081357e-46) {
		tmp = x * (y * z);
	} else {
		tmp = c * (a * j);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: tmp
    if (c <= (-4.22744243571953d-17)) then
        tmp = a * (c * j)
    else if (c <= 2.3744995975081357d-46) then
        tmp = x * (y * z)
    else
        tmp = c * (a * j)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (c <= -4.22744243571953e-17) {
		tmp = a * (c * j);
	} else if (c <= 2.3744995975081357e-46) {
		tmp = x * (y * z);
	} else {
		tmp = c * (a * j);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -4.22744243571953e-17:
		tmp = a * (c * j)
	elif c <= 2.3744995975081357e-46:
		tmp = x * (y * z)
	else:
		tmp = c * (a * j)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -4.22744243571953e-17)
		tmp = Float64(a * Float64(c * j));
	elseif (c <= 2.3744995975081357e-46)
		tmp = Float64(x * Float64(y * z));
	else
		tmp = Float64(c * Float64(a * j));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -4.22744243571953e-17)
		tmp = a * (c * j);
	elseif (c <= 2.3744995975081357e-46)
		tmp = x * (y * z);
	else
		tmp = c * (a * j);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -4.22744243571953e-17], N[(a * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.3744995975081357e-46], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET tmp_1 = IF (c <= (237449959750813567767338879181660597697567044694056387375925870251614618261414280016232976917413820668384234813645954249861080853634121012873947620391845703125e-204)) THEN (x * (y * z)) ELSE (c * (a * j)) ENDIF IN
	LET tmp = IF (c <= (-4227442435719529768718577901922876189090539332526841320714083849452435970306396484375e-101)) THEN (a * (c * j)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -4.2274424357195298e-17

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]

   5. Taylor expanded in x around 0

      \[\leadsto a \cdot \left(c \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.5%

      \[\leadsto a \cdot \left(c \cdot j\right) \]

   if -4.2274424357195298e-17 < c < 2.3744995975081357e-46

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   5. Taylor expanded in x around inf

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

   7. Applied rewrites 22.9%

      \[\leadsto x \cdot \left(y \cdot z\right) \]

   if 2.3744995975081357e-46 < c

   1. Initial program 73.5%

      \[\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. Taylor expanded in c around inf

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(a \cdot j - b \cdot z\right) \]

   5. Taylor expanded in z around 0

      \[\leadsto c \cdot \left(a \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.3%

      \[\leadsto c \cdot \left(a \cdot j\right) \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 25: 29.1% accurate, 2.8× speedup

Math

\[\begin{array}{l} t_1 := a \cdot \left(c \cdot j\right)\\ \mathbf{if}\;c \leq -4.22744243571953 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 2.3744995975081357 \cdot 10^{-46}:\\ \;\;\;\;x \cdot \left(y \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* a (* c j))))
  (if (<= c -4.22744243571953e-17)
    t_1
    (if (<= c 2.3744995975081357e-46) (* 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 = a * (c * j);
	double tmp;
	if (c <= -4.22744243571953e-17) {
		tmp = t_1;
	} else if (c <= 2.3744995975081357e-46) {
		tmp = x * (y * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8), intent (in) :: j
    real(8) :: t_1
    real(8) :: tmp
    t_1 = a * (c * j)
    if (c <= (-4.22744243571953d-17)) then
        tmp = t_1
    else if (c <= 2.3744995975081357d-46) then
        tmp = x * (y * z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = a * (c * j);
	double tmp;
	if (c <= -4.22744243571953e-17) {
		tmp = t_1;
	} else if (c <= 2.3744995975081357e-46) {
		tmp = x * (y * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = a * (c * j)
	tmp = 0
	if c <= -4.22744243571953e-17:
		tmp = t_1
	elif c <= 2.3744995975081357e-46:
		tmp = x * (y * z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(a * Float64(c * j))
	tmp = 0.0
	if (c <= -4.22744243571953e-17)
		tmp = t_1;
	elseif (c <= 2.3744995975081357e-46)
		tmp = Float64(x * Float64(y * z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	t_1 = a * (c * j);
	tmp = 0.0;
	if (c <= -4.22744243571953e-17)
		tmp = t_1;
	elseif (c <= 2.3744995975081357e-46)
		tmp = x * (y * z);
	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[(a * N[(c * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -4.22744243571953e-17], t$95$1, If[LessEqual[c, 2.3744995975081357e-46], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	LET t_1 = (a * (c * j)) IN
		LET tmp_1 = IF (c <= (237449959750813567767338879181660597697567044694056387375925870251614618261414280016232976917413820668384234813645954249861080853634121012873947620391845703125e-204)) THEN (x * (y * z)) ELSE t_1 ENDIF IN
		LET tmp = IF (c <= (-4227442435719529768718577901922876189090539332526841320714083849452435970306396484375e-101)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if c < -4.2274424357195298e-17 or 2.3744995975081357e-46 < c

   1. Initial program 73.5%

      \[\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. Taylor expanded in a around inf

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

   4. Applied rewrites 39.2%

      \[\leadsto a \cdot \mathsf{fma}\left(-1, t \cdot x, c \cdot j\right) \]

   5. Taylor expanded in x around 0

      \[\leadsto a \cdot \left(c \cdot j\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 22.5%

      \[\leadsto a \cdot \left(c \cdot j\right) \]

   if -4.2274424357195298e-17 < c < 2.3744995975081357e-46

   1. Initial program 73.5%

      \[\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. Taylor expanded in y around inf

      \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
   3. Step-by-step derivation

   4. Applied rewrites 39.6%

      \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

   5. Taylor expanded in x around inf

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

   7. Applied rewrites 22.9%

      \[\leadsto x \cdot \left(y \cdot z\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 26: 22.9% accurate, 5.9× speedup

Math

\[x \cdot \left(y \cdot z\right) \]

FPCore

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

Fortran

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c, i, j):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf],
	c in [-inf, +inf],
	i in [-inf, +inf],
	j in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c, i, j: real): real =
	x * (y * z)
END code

Derivation

1. Initial program 73.5%

   \[\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. Taylor expanded in y around inf

   \[\leadsto y \cdot \left(-1 \cdot \left(i \cdot j\right) + x \cdot z\right) \]
3. Step-by-step derivation

4. Applied rewrites 39.6%

   \[\leadsto y \cdot \mathsf{fma}\left(-1, i \cdot j, x \cdot z\right) \]

5. Taylor expanded in x around inf

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

7. Applied rewrites 22.9%

   \[\leadsto x \cdot \left(y \cdot z\right) \]
8. Add Preprocessing

Reproduce

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