Linear.Matrix:det33 from linear-1.19.1.3

Percentage Accurate: 73.5% → 81.4%

Time: 6.4s

Alternatives: 20

Speedup: 0.5×

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
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) - (i * a)))) + (j * ((c * t) - (i * y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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) - (i * a)))) + (j * ((c * t) - (i * y)))
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 - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right) \]

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
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) - (i * a)))) + (j * ((c * t) - (i * y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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

Alternative 1: 81.4% accurate, 0.5× speedup

Math

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

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((c * t) - (i * y));
	double t_2 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + t_1;
	double tmp;
	if (t_2 <= ((double) INFINITY)) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = j * ((c * t) - (i * y));
	double t_2 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + t_1;
	double tmp;
	if (t_2 <= Double.POSITIVE_INFINITY) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

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

   1. Initial program 73.5%

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

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

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

Alternative 2: 67.8% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := b \cdot \left(a \cdot i - c \cdot z\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;c \leq -6.229178428956133 \cdot 10^{-8}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 3.394134153849403 \cdot 10^{-55}:\\ \;\;\;\;\mathsf{fma}\left(z \cdot y - a \cdot t, x, \left(b \cdot a - j \cdot y\right) \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 (+ (* b (- (* a i) (* c z))) (* j (- (* c t) (* i y))))))
  (if (<= c -6.229178428956133e-8)
    t_1
    (if (<= c 3.394134153849403e-55)
      (fma (- (* z y) (* a t)) x (* (- (* b a) (* j y)) i))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double t_1 = (b * ((a * i) - (c * z))) + (j * ((c * t) - (i * y)));
	double tmp;
	if (c <= -6.229178428956133e-8) {
		tmp = t_1;
	} else if (c <= 3.394134153849403e-55) {
		tmp = fma(((z * y) - (a * t)), x, (((b * a) - (j * y)) * i));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(Float64(b * Float64(Float64(a * i) - Float64(c * z))) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	tmp = 0.0
	if (c <= -6.229178428956133e-8)
		tmp = t_1;
	elseif (c <= 3.394134153849403e-55)
		tmp = fma(Float64(Float64(z * y) - Float64(a * t)), x, Float64(Float64(Float64(b * a) - Float64(j * 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[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -6.229178428956133e-8], t$95$1, If[LessEqual[c, 3.394134153849403e-55], N[(N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * x + N[(N[(N[(b * a), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $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 * ((a * i) - (c * z))) + (j * ((c * t) - (i * y)))) IN
		LET tmp_1 = IF (c <= (339413415384940321135805987628484069330966260123049895614527295739469105512233713302961566707491819251176607736041509431569105137752560830133319313972606323659420013427734375e-228)) THEN ((((z * y) - (a * t)) * x) + (((b * a) - (j * y)) * i)) ELSE t_1 ENDIF IN
		LET tmp = IF (c <= (-62291784289561333317120409534817238039750009193085134029388427734375e-75)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if c < -6.2291784289561333e-8 or 3.3941341538494032e-55 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in b around inf

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

   4. Applied rewrites 58.3%

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

   if -6.2291784289561333e-8 < c < 3.3941341538494032e-55

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

Alternative 3: 66.7% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := c \cdot \left(j \cdot t - b \cdot z\right)\\ \mathbf{if}\;c \leq -9.633691020502869 \cdot 10^{+142}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq 3.394134153849403 \cdot 10^{-55}:\\ \;\;\;\;\mathsf{fma}\left(z \cdot y - a \cdot t, x, \left(b \cdot a - j \cdot y\right) \cdot i\right)\\ \mathbf{elif}\;c \leq 1.2749766758980905 \cdot 10^{+193}:\\ \;\;\;\;-1 \cdot \left(b \cdot \left(c \cdot z\right)\right) + j \cdot \left(c \cdot t - 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 (* c (- (* j t) (* b z)))))
  (if (<= c -9.633691020502869e+142)
    t_1
    (if (<= c 3.394134153849403e-55)
      (fma (- (* z y) (* a t)) x (* (- (* b a) (* j y)) i))
      (if (<= c 1.2749766758980905e+193)
        (+ (* -1.0 (* b (* c z))) (* j (- (* c t) (* 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 = c * ((j * t) - (b * z));
	double tmp;
	if (c <= -9.633691020502869e+142) {
		tmp = t_1;
	} else if (c <= 3.394134153849403e-55) {
		tmp = fma(((z * y) - (a * t)), x, (((b * a) - (j * y)) * i));
	} else if (c <= 1.2749766758980905e+193) {
		tmp = (-1.0 * (b * (c * z))) + (j * ((c * t) - (i * y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(j * t) - Float64(b * z)))
	tmp = 0.0
	if (c <= -9.633691020502869e+142)
		tmp = t_1;
	elseif (c <= 3.394134153849403e-55)
		tmp = fma(Float64(Float64(z * y) - Float64(a * t)), x, Float64(Float64(Float64(b * a) - Float64(j * y)) * i));
	elseif (c <= 1.2749766758980905e+193)
		tmp = Float64(Float64(-1.0 * Float64(b * Float64(c * z))) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(j * t), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -9.633691020502869e+142], t$95$1, If[LessEqual[c, 3.394134153849403e-55], N[(N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * x + N[(N[(N[(b * a), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.2749766758980905e+193], N[(N[(-1.0 * N[(b * N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $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 = (c * ((j * t) - (b * z))) IN
		LET tmp_2 = IF (c <= (12749766758980905167582992467129602558124469471170814976551598878263854656484749197561046059513104343060602115146267779124401218151189544162935017071205393583551033168851697947510325273727860736)) THEN (((-1) * (b * (c * z))) + (j * ((c * t) - (i * y)))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (c <= (339413415384940321135805987628484069330966260123049895614527295739469105512233713302961566707491819251176607736041509431569105137752560830133319313972606323659420013427734375e-228)) THEN ((((z * y) - (a * t)) * x) + (((b * a) - (j * y)) * i)) ELSE tmp_2 ENDIF IN
		LET tmp = IF (c <= (-96336910205028685884602951513105959010953219732243842629084865843883543997715246908379573168049277540785224168069696653150689095905573309775872)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -9.6336910205028686e142 or 1.2749766758980905e193 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

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

   if -9.6336910205028686e142 < c < 3.3941341538494032e-55

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

   if 3.3941341538494032e-55 < c < 1.2749766758980905e193

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 48.5%

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

Alternative 4: 63.0% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(a, b \cdot i, x \cdot \left(y \cdot z - a \cdot t\right)\right)\\ \mathbf{if}\;x \leq -1.5471512694356623 \cdot 10^{+116}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -1.2013168496741021 \cdot 10^{+54}:\\ \;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;x \leq 0.022144459606016048:\\ \;\;\;\;a \cdot \left(b \cdot i\right) + j \cdot \left(c \cdot t - 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 (fma a (* b i) (* x (- (* y z) (* a t))))))
  (if (<= x -1.5471512694356623e+116)
    t_1
    (if (<= x -1.2013168496741021e+54)
      (+ (* z (- (* x y) (* b c))) (* j (* c t)))
      (if (<= x 0.022144459606016048)
        (+ (* a (* b i)) (* j (- (* c t) (* 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 = fma(a, (b * i), (x * ((y * z) - (a * t))));
	double tmp;
	if (x <= -1.5471512694356623e+116) {
		tmp = t_1;
	} else if (x <= -1.2013168496741021e+54) {
		tmp = (z * ((x * y) - (b * c))) + (j * (c * t));
	} else if (x <= 0.022144459606016048) {
		tmp = (a * (b * i)) + (j * ((c * t) - (i * y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = fma(a, Float64(b * i), Float64(x * Float64(Float64(y * z) - Float64(a * t))))
	tmp = 0.0
	if (x <= -1.5471512694356623e+116)
		tmp = t_1;
	elseif (x <= -1.2013168496741021e+54)
		tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + Float64(j * Float64(c * t)));
	elseif (x <= 0.022144459606016048)
		tmp = Float64(Float64(a * Float64(b * i)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.5471512694356623e+116], t$95$1, If[LessEqual[x, -1.2013168496741021e+54], N[(N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.022144459606016048], N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $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 = ((a * (b * i)) + (x * ((y * z) - (a * t)))) IN
		LET tmp_2 = IF (x <= (221444596060160481254541764428722672164440155029296875e-55)) THEN ((a * (b * i)) + (j * ((c * t) - (i * y)))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (x <= (-1201316849674102101299448436820634959822356794455359488)) THEN ((z * ((x * y) - (b * c))) + (j * (c * t))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (x <= (-154715126943566230726242673080851178162037156232461144715412071784722552268023985180212029627568016372692398309900288)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -1.5471512694356623e116 or 0.022144459606016048 < x

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

   7. Taylor expanded in j around 0

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

   9. Applied rewrites 52.9%

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

   if -1.5471512694356623e116 < x < -1.2013168496741021e54

   1. Initial program 73.5%

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

   2. Taylor expanded in z around inf

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

   4. Applied rewrites 59.0%

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

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 49.7%

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

   if -1.2013168496741021e54 < x < 0.022144459606016048

   1. Initial program 73.5%

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

   2. Taylor expanded in i around inf

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

   4. Applied rewrites 49.4%

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

Alternative 5: 62.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(a, b \cdot i, x \cdot \left(y \cdot z - a \cdot t\right)\right)\\ \mathbf{if}\;x \leq -1.9720246332974511 \cdot 10^{+118}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -1.618704440112927 \cdot 10^{+55}:\\ \;\;\;\;c \cdot \left(j \cdot t - b \cdot z\right)\\ \mathbf{elif}\;x \leq 0.022144459606016048:\\ \;\;\;\;a \cdot \left(b \cdot i\right) + j \cdot \left(c \cdot t - 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 (fma a (* b i) (* x (- (* y z) (* a t))))))
  (if (<= x -1.9720246332974511e+118)
    t_1
    (if (<= x -1.618704440112927e+55)
      (* c (- (* j t) (* b z)))
      (if (<= x 0.022144459606016048)
        (+ (* a (* b i)) (* j (- (* c t) (* 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 = fma(a, (b * i), (x * ((y * z) - (a * t))));
	double tmp;
	if (x <= -1.9720246332974511e+118) {
		tmp = t_1;
	} else if (x <= -1.618704440112927e+55) {
		tmp = c * ((j * t) - (b * z));
	} else if (x <= 0.022144459606016048) {
		tmp = (a * (b * i)) + (j * ((c * t) - (i * y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = fma(a, Float64(b * i), Float64(x * Float64(Float64(y * z) - Float64(a * t))))
	tmp = 0.0
	if (x <= -1.9720246332974511e+118)
		tmp = t_1;
	elseif (x <= -1.618704440112927e+55)
		tmp = Float64(c * Float64(Float64(j * t) - Float64(b * z)));
	elseif (x <= 0.022144459606016048)
		tmp = Float64(Float64(a * Float64(b * i)) + Float64(j * Float64(Float64(c * t) - Float64(i * y))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.9720246332974511e+118], t$95$1, If[LessEqual[x, -1.618704440112927e+55], N[(c * N[(N[(j * t), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.022144459606016048], N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $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 = ((a * (b * i)) + (x * ((y * z) - (a * t)))) IN
		LET tmp_2 = IF (x <= (221444596060160481254541764428722672164440155029296875e-55)) THEN ((a * (b * i)) + (j * ((c * t) - (i * y)))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (x <= (-16187044401129270249589989982276538002572372098341142528)) THEN (c * ((j * t) - (b * z))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (x <= (-19720246332974511122204277351766831057503645357761414554323923617399466576337288369474865031203365682255943632244703232)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -1.9720246332974511e118 or 0.022144459606016048 < x

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

   7. Taylor expanded in j around 0

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

   9. Applied rewrites 52.9%

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

   if -1.9720246332974511e118 < x < -1.618704440112927e55

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

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

   if -1.618704440112927e55 < x < 0.022144459606016048

   1. Initial program 73.5%

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

   2. Taylor expanded in i around inf

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

   4. Applied rewrites 49.4%

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

Alternative 6: 62.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := -1 \cdot \left(b \cdot \left(c \cdot z\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;j \leq -2108901786114573.8:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 4.507423004714082 \cdot 10^{-45}:\\ \;\;\;\;\mathsf{fma}\left(a, b \cdot i, 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 (+ (* -1.0 (* b (* c z))) (* j (- (* c t) (* i y))))))
  (if (<= j -2108901786114573.8)
    t_1
    (if (<= j 4.507423004714082e-45)
      (fma a (* b i) (* 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 = (-1.0 * (b * (c * z))) + (j * ((c * t) - (i * y)));
	double tmp;
	if (j <= -2108901786114573.8) {
		tmp = t_1;
	} else if (j <= 4.507423004714082e-45) {
		tmp = fma(a, (b * i), (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 = Float64(Float64(-1.0 * Float64(b * Float64(c * z))) + Float64(j * Float64(Float64(c * t) - Float64(i * y))))
	tmp = 0.0
	if (j <= -2108901786114573.8)
		tmp = t_1;
	elseif (j <= 4.507423004714082e-45)
		tmp = fma(a, Float64(b * i), 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[(N[(-1.0 * N[(b * N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2108901786114573.8], t$95$1, If[LessEqual[j, 4.507423004714082e-45], N[(a * N[(b * i), $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 = (((-1) * (b * (c * z))) + (j * ((c * t) - (i * y)))) IN
		LET tmp_1 = IF (j <= (4507423004714081729727796072854560322357094098802283969631236850887410437927775056099344175028087020899968863515104577910364014314836822450160980224609375e-198)) THEN ((a * (b * i)) + (x * ((y * z) - (a * t)))) ELSE t_1 ENDIF IN
		LET tmp = IF (j <= (-210890178611457375e-2)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if j < -2108901786114573.8 or 4.5074230047140817e-45 < j

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 48.5%

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

   if -2108901786114573.8 < j < 4.5074230047140817e-45

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

   7. Taylor expanded in j around 0

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

   9. Applied rewrites 52.9%

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

Alternative 7: 60.0% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \left(b \cdot a - j \cdot y\right) \cdot i\\ \mathbf{if}\;i \leq -2.7206078196875836 \cdot 10^{+99}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;i \leq -2.1595436636958158 \cdot 10^{+26}:\\ \;\;\;\;z \cdot \mathsf{fma}\left(-1, b \cdot c, x \cdot y\right)\\ \mathbf{elif}\;i \leq 18801397.454633582:\\ \;\;\;\;\mathsf{fma}\left(j, c \cdot t, 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 (* (- (* b a) (* j y)) i)))
  (if (<= i -2.7206078196875836e+99)
    t_1
    (if (<= i -2.1595436636958158e+26)
      (* z (fma -1.0 (* b c) (* x y)))
      (if (<= i 18801397.454633582)
        (fma j (* c t) (* 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 = ((b * a) - (j * y)) * i;
	double tmp;
	if (i <= -2.7206078196875836e+99) {
		tmp = t_1;
	} else if (i <= -2.1595436636958158e+26) {
		tmp = z * fma(-1.0, (b * c), (x * y));
	} else if (i <= 18801397.454633582) {
		tmp = fma(j, (c * t), (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 = Float64(Float64(Float64(b * a) - Float64(j * y)) * i)
	tmp = 0.0
	if (i <= -2.7206078196875836e+99)
		tmp = t_1;
	elseif (i <= -2.1595436636958158e+26)
		tmp = Float64(z * fma(-1.0, Float64(b * c), Float64(x * y)));
	elseif (i <= 18801397.454633582)
		tmp = fma(j, Float64(c * t), 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[(N[(N[(b * a), $MachinePrecision] - N[(j * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -2.7206078196875836e+99], t$95$1, If[LessEqual[i, -2.1595436636958158e+26], N[(z * N[(-1.0 * N[(b * c), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 18801397.454633582], N[(j * N[(c * t), $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 = (((b * a) - (j * y)) * i) IN
		LET tmp_2 = IF (i <= (188013974546335823833942413330078125e-28)) THEN ((j * (c * t)) + (x * ((y * z) - (a * t)))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (i <= (-215954366369581578663755776)) THEN (z * (((-1) * (b * c)) + (x * y))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (i <= (-2720607819687583560412158566814248258939647941418288462590016465231464500696285329884172448086097920)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if i < -2.7206078196875836e99 or 18801397.454633582 < i

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   if -2.7206078196875836e99 < i < -2.1595436636958158e26

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   8. Applied rewrites 39.6%

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

   9. Taylor expanded in z around -inf

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

   11. Applied rewrites 39.2%

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

   if -2.1595436636958158e26 < i < 18801397.454633582

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

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

   5. Taylor expanded in y around 0

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

   7. Applied rewrites 51.3%

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

Alternative 8: 59.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;j \leq -2108901786114573.8:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 5.049113101241169 \cdot 10^{-53}:\\ \;\;\;\;\mathsf{fma}\left(a, b \cdot i, 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 (* j (- (* c t) (* i y)))))
  (if (<= j -2108901786114573.8)
    t_1
    (if (<= j 5.049113101241169e-53)
      (fma a (* b i) (* 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 = j * ((c * t) - (i * y));
	double tmp;
	if (j <= -2108901786114573.8) {
		tmp = t_1;
	} else if (j <= 5.049113101241169e-53) {
		tmp = fma(a, (b * i), (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 = Float64(j * Float64(Float64(c * t) - Float64(i * y)))
	tmp = 0.0
	if (j <= -2108901786114573.8)
		tmp = t_1;
	elseif (j <= 5.049113101241169e-53)
		tmp = fma(a, Float64(b * i), 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[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2108901786114573.8], t$95$1, If[LessEqual[j, 5.049113101241169e-53], N[(a * N[(b * i), $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 * t) - (i * y))) IN
		LET tmp_1 = IF (j <= (504911310124116862516412390495585685384041342703336741253828183620955976047705667504733318361990906140893864162215211993381702127131442636720493055690894834697246551513671875e-226)) THEN ((a * (b * i)) + (x * ((y * z) - (a * t)))) ELSE t_1 ENDIF IN
		LET tmp = IF (j <= (-210890178611457375e-2)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if j < -2108901786114573.8 or 5.0491131012411686e-53 < j

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   if -2108901786114573.8 < j < 5.0491131012411686e-53

   1. Initial program 73.5%

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

   2. Taylor expanded in c around 0

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

   4. Applied rewrites 58.9%

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

   6. Applied rewrites 61.6%

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

   7. Taylor expanded in j around 0

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

   9. Applied rewrites 52.9%

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

Alternative 9: 52.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := c \cdot \left(j \cdot t - b \cdot z\right)\\ \mathbf{if}\;c \leq -1.7019462628232986 \cdot 10^{+75}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;c \leq -180234581.23655525:\\ \;\;\;\;\left(i \cdot b - t \cdot x\right) \cdot a\\ \mathbf{elif}\;c \leq 6.442984989259662 \cdot 10^{-49}:\\ \;\;\;\;\left(z \cdot x - j \cdot i\right) \cdot y\\ \mathbf{elif}\;c \leq 7.672749651458509 \cdot 10^{+56}:\\ \;\;\;\;j \cdot \left(c \cdot t - 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 (* c (- (* j t) (* b z)))))
  (if (<= c -1.7019462628232986e+75)
    t_1
    (if (<= c -180234581.23655525)
      (* (- (* i b) (* t x)) a)
      (if (<= c 6.442984989259662e-49)
        (* (- (* z x) (* j i)) y)
        (if (<= c 7.672749651458509e+56)
          (* j (- (* c t) (* 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 = c * ((j * t) - (b * z));
	double tmp;
	if (c <= -1.7019462628232986e+75) {
		tmp = t_1;
	} else if (c <= -180234581.23655525) {
		tmp = ((i * b) - (t * x)) * a;
	} else if (c <= 6.442984989259662e-49) {
		tmp = ((z * x) - (j * i)) * y;
	} else if (c <= 7.672749651458509e+56) {
		tmp = j * ((c * t) - (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 = c * ((j * t) - (b * z))
    if (c <= (-1.7019462628232986d+75)) then
        tmp = t_1
    else if (c <= (-180234581.23655525d0)) then
        tmp = ((i * b) - (t * x)) * a
    else if (c <= 6.442984989259662d-49) then
        tmp = ((z * x) - (j * i)) * y
    else if (c <= 7.672749651458509d+56) then
        tmp = j * ((c * t) - (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 = c * ((j * t) - (b * z));
	double tmp;
	if (c <= -1.7019462628232986e+75) {
		tmp = t_1;
	} else if (c <= -180234581.23655525) {
		tmp = ((i * b) - (t * x)) * a;
	} else if (c <= 6.442984989259662e-49) {
		tmp = ((z * x) - (j * i)) * y;
	} else if (c <= 7.672749651458509e+56) {
		tmp = j * ((c * t) - (i * y));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = c * ((j * t) - (b * z))
	tmp = 0
	if c <= -1.7019462628232986e+75:
		tmp = t_1
	elif c <= -180234581.23655525:
		tmp = ((i * b) - (t * x)) * a
	elif c <= 6.442984989259662e-49:
		tmp = ((z * x) - (j * i)) * y
	elif c <= 7.672749651458509e+56:
		tmp = j * ((c * t) - (i * y))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(c * Float64(Float64(j * t) - Float64(b * z)))
	tmp = 0.0
	if (c <= -1.7019462628232986e+75)
		tmp = t_1;
	elseif (c <= -180234581.23655525)
		tmp = Float64(Float64(Float64(i * b) - Float64(t * x)) * a);
	elseif (c <= 6.442984989259662e-49)
		tmp = Float64(Float64(Float64(z * x) - Float64(j * i)) * y);
	elseif (c <= 7.672749651458509e+56)
		tmp = Float64(j * Float64(Float64(c * t) - 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 = c * ((j * t) - (b * z));
	tmp = 0.0;
	if (c <= -1.7019462628232986e+75)
		tmp = t_1;
	elseif (c <= -180234581.23655525)
		tmp = ((i * b) - (t * x)) * a;
	elseif (c <= 6.442984989259662e-49)
		tmp = ((z * x) - (j * i)) * y;
	elseif (c <= 7.672749651458509e+56)
		tmp = j * ((c * t) - (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[(c * N[(N[(j * t), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.7019462628232986e+75], t$95$1, If[LessEqual[c, -180234581.23655525], N[(N[(N[(i * b), $MachinePrecision] - N[(t * x), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[c, 6.442984989259662e-49], N[(N[(N[(z * x), $MachinePrecision] - N[(j * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[c, 7.672749651458509e+56], N[(j * N[(N[(c * t), $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 = (c * ((j * t) - (b * z))) IN
		LET tmp_3 = IF (c <= (767274965145850909945606349392011109397449711350546694144)) THEN (j * ((c * t) - (i * y))) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (c <= (6442984989259661644277067447809992133465394772541462810709058888315417259652197430052637461905659662978092225789385408935526500240342784309177659451961517333984375e-211)) THEN (((z * x) - (j * i)) * y) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (c <= (-1802345812365552484989166259765625e-25)) THEN (((i * b) - (t * x)) * a) ELSE tmp_2 ENDIF IN
		LET tmp = IF (c <= (-1701946262823298600069447447417415130285642743261765876624519559976717385728)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if c < -1.7019462628232986e75 or 7.6727496514585091e56 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

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

   if -1.7019462628232986e75 < c < -180234581.23655525

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   8. Applied rewrites 39.6%

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

   if -180234581.23655525 < c < 6.4429849892596616e-49

   1. Initial program 73.5%

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

   2. Taylor expanded in 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.5%

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

   6. Applied rewrites 39.5%

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

   if 6.4429849892596616e-49 < c < 7.6727496514585091e56

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

Alternative 10: 49.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} t_1 := j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{if}\;j \leq -2108901786114573.8:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;j \leq 4.690619634809764 \cdot 10^{-188}:\\ \;\;\;\;\left(i \cdot b - 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 (* j (- (* c t) (* i y)))))
  (if (<= j -2108901786114573.8)
    t_1
    (if (<= j 4.690619634809764e-188) (* (- (* i b) (* 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 = j * ((c * t) - (i * y));
	double tmp;
	if (j <= -2108901786114573.8) {
		tmp = t_1;
	} else if (j <= 4.690619634809764e-188) {
		tmp = ((i * b) - (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 = j * ((c * t) - (i * y))
    if (j <= (-2108901786114573.8d0)) then
        tmp = t_1
    else if (j <= 4.690619634809764d-188) then
        tmp = ((i * b) - (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 = j * ((c * t) - (i * y));
	double tmp;
	if (j <= -2108901786114573.8) {
		tmp = t_1;
	} else if (j <= 4.690619634809764e-188) {
		tmp = ((i * b) - (t * x)) * a;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * ((c * t) - (i * y))
	tmp = 0
	if j <= -2108901786114573.8:
		tmp = t_1
	elif j <= 4.690619634809764e-188:
		tmp = ((i * b) - (t * x)) * a
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(Float64(c * t) - Float64(i * y)))
	tmp = 0.0
	if (j <= -2108901786114573.8)
		tmp = t_1;
	elseif (j <= 4.690619634809764e-188)
		tmp = Float64(Float64(Float64(i * b) - 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 = j * ((c * t) - (i * y));
	tmp = 0.0;
	if (j <= -2108901786114573.8)
		tmp = t_1;
	elseif (j <= 4.690619634809764e-188)
		tmp = ((i * b) - (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[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2108901786114573.8], t$95$1, If[LessEqual[j, 4.690619634809764e-188], N[(N[(N[(i * b), $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 = (j * ((c * t) - (i * y))) IN
		LET tmp_1 = IF (j <= (46906196348097638772822114255760174898222591543356561854763603027133311403897275365033435418954801678511344127530813172980398823823433765030060643673852036992154977996855552059582413666507891751005577189275904392321630516778904150118002217412835137382551194687667679568746555933675995813544863797393025667918352830777045322230043749206483743065912622417469171444321236629577694648363584166236047136668388046015776169753119574273963024433663359540926107715819171062321402132511138916015625e-675)) THEN (((i * b) - (t * x)) * a) ELSE t_1 ENDIF IN
		LET tmp = IF (j <= (-210890178611457375e-2)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if j < -2108901786114573.8 or 4.6906196348097639e-188 < j

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   if -2108901786114573.8 < j < 4.6906196348097639e-188

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   8. Applied rewrites 39.6%

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

Alternative 11: 43.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;b \leq -8.218623922307872 \cdot 10^{+81}:\\ \;\;\;\;\left(a \cdot b\right) \cdot i\\ \mathbf{elif}\;b \leq 43367.24730772068:\\ \;\;\;\;j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;c \cdot \left(j \cdot t - b \cdot z\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= b -8.218623922307872e+81)
  (* (* a b) i)
  (if (<= b 43367.24730772068)
    (* j (- (* c t) (* i y)))
    (* c (- (* j t) (* 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 (b <= -8.218623922307872e+81) {
		tmp = (a * b) * i;
	} else if (b <= 43367.24730772068) {
		tmp = j * ((c * t) - (i * y));
	} else {
		tmp = c * ((j * t) - (b * z));
	}
	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 (b <= (-8.218623922307872d+81)) then
        tmp = (a * b) * i
    else if (b <= 43367.24730772068d0) then
        tmp = j * ((c * t) - (i * y))
    else
        tmp = c * ((j * t) - (b * z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (b <= -8.218623922307872e+81) {
		tmp = (a * b) * i;
	} else if (b <= 43367.24730772068) {
		tmp = j * ((c * t) - (i * y));
	} else {
		tmp = c * ((j * t) - (b * z));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if b <= -8.218623922307872e+81:
		tmp = (a * b) * i
	elif b <= 43367.24730772068:
		tmp = j * ((c * t) - (i * y))
	else:
		tmp = c * ((j * t) - (b * z))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (b <= -8.218623922307872e+81)
		tmp = Float64(Float64(a * b) * i);
	elseif (b <= 43367.24730772068)
		tmp = Float64(j * Float64(Float64(c * t) - Float64(i * y)));
	else
		tmp = Float64(c * Float64(Float64(j * t) - Float64(b * z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (b <= -8.218623922307872e+81)
		tmp = (a * b) * i;
	elseif (b <= 43367.24730772068)
		tmp = j * ((c * t) - (i * y));
	else
		tmp = c * ((j * t) - (b * z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.218623922307872e+81], N[(N[(a * b), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, 43367.24730772068], N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * N[(N[(j * t), $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_1 = IF (b <= (4336724730772068141959607601165771484375e-35)) THEN (j * ((c * t) - (i * y))) ELSE (c * ((j * t) - (b * z))) ENDIF IN
	LET tmp = IF (b <= (-8218623922307871632995953476538928035766776002267170667356253249094850969633554432)) THEN ((a * b) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -8.2186239223078716e81

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   7. Taylor expanded in y around 0

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

   9. Applied rewrites 22.9%

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

   if -8.2186239223078716e81 < b < 43367.247307720681

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   if 43367.247307720681 < b

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

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

Alternative 12: 41.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;b \leq -8.218623922307872 \cdot 10^{+81}:\\ \;\;\;\;\left(a \cdot b\right) \cdot i\\ \mathbf{elif}\;b \leq 43367.24730772068:\\ \;\;\;\;j \cdot \left(c \cdot t - i \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;\left(-b \cdot z\right) \cdot c\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= b -8.218623922307872e+81)
  (* (* a b) i)
  (if (<= b 43367.24730772068)
    (* j (- (* c t) (* i y)))
    (* (- (* b z)) c))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (b <= -8.218623922307872e+81) {
		tmp = (a * b) * i;
	} else if (b <= 43367.24730772068) {
		tmp = j * ((c * t) - (i * y));
	} else {
		tmp = -(b * z) * c;
	}
	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 (b <= (-8.218623922307872d+81)) then
        tmp = (a * b) * i
    else if (b <= 43367.24730772068d0) then
        tmp = j * ((c * t) - (i * y))
    else
        tmp = -(b * z) * c
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (b <= -8.218623922307872e+81) {
		tmp = (a * b) * i;
	} else if (b <= 43367.24730772068) {
		tmp = j * ((c * t) - (i * y));
	} else {
		tmp = -(b * z) * c;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if b <= -8.218623922307872e+81:
		tmp = (a * b) * i
	elif b <= 43367.24730772068:
		tmp = j * ((c * t) - (i * y))
	else:
		tmp = -(b * z) * c
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (b <= -8.218623922307872e+81)
		tmp = Float64(Float64(a * b) * i);
	elseif (b <= 43367.24730772068)
		tmp = Float64(j * Float64(Float64(c * t) - Float64(i * y)));
	else
		tmp = Float64(Float64(-Float64(b * z)) * c);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (b <= -8.218623922307872e+81)
		tmp = (a * b) * i;
	elseif (b <= 43367.24730772068)
		tmp = j * ((c * t) - (i * y));
	else
		tmp = -(b * z) * c;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.218623922307872e+81], N[(N[(a * b), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, 43367.24730772068], N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-N[(b * z), $MachinePrecision]) * c), $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 (b <= (4336724730772068141959607601165771484375e-35)) THEN (j * ((c * t) - (i * y))) ELSE ((- (b * z)) * c) ENDIF IN
	LET tmp = IF (b <= (-8218623922307871632995953476538928035766776002267170667356253249094850969633554432)) THEN ((a * b) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -8.2186239223078716e81

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   7. Taylor expanded in y around 0

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

   9. Applied rewrites 22.9%

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

   if -8.2186239223078716e81 < b < 43367.247307720681

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   if 43367.247307720681 < b

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(j \cdot t - 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 \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 13: 30.3% accurate, 2.1× speedup

Math

\[\begin{array}{l} \mathbf{if}\;b \leq -7.616692883967156 \cdot 10^{+81}:\\ \;\;\;\;\left(a \cdot b\right) \cdot i\\ \mathbf{elif}\;b \leq -1.0476813589638029 \cdot 10^{-243}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;b \leq 21747.96264972048:\\ \;\;\;\;j \cdot \left(\left(-i\right) \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;\left(-b \cdot z\right) \cdot c\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= b -7.616692883967156e+81)
  (* (* a b) i)
  (if (<= b -1.0476813589638029e-243)
    (* j (* c t))
    (if (<= b 21747.96264972048)
      (* j (* (- i) y))
      (* (- (* b z)) c)))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (b <= -7.616692883967156e+81) {
		tmp = (a * b) * i;
	} else if (b <= -1.0476813589638029e-243) {
		tmp = j * (c * t);
	} else if (b <= 21747.96264972048) {
		tmp = j * (-i * y);
	} else {
		tmp = -(b * z) * c;
	}
	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 (b <= (-7.616692883967156d+81)) then
        tmp = (a * b) * i
    else if (b <= (-1.0476813589638029d-243)) then
        tmp = j * (c * t)
    else if (b <= 21747.96264972048d0) then
        tmp = j * (-i * y)
    else
        tmp = -(b * z) * c
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
	double tmp;
	if (b <= -7.616692883967156e+81) {
		tmp = (a * b) * i;
	} else if (b <= -1.0476813589638029e-243) {
		tmp = j * (c * t);
	} else if (b <= 21747.96264972048) {
		tmp = j * (-i * y);
	} else {
		tmp = -(b * z) * c;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if b <= -7.616692883967156e+81:
		tmp = (a * b) * i
	elif b <= -1.0476813589638029e-243:
		tmp = j * (c * t)
	elif b <= 21747.96264972048:
		tmp = j * (-i * y)
	else:
		tmp = -(b * z) * c
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (b <= -7.616692883967156e+81)
		tmp = Float64(Float64(a * b) * i);
	elseif (b <= -1.0476813589638029e-243)
		tmp = Float64(j * Float64(c * t));
	elseif (b <= 21747.96264972048)
		tmp = Float64(j * Float64(Float64(-i) * y));
	else
		tmp = Float64(Float64(-Float64(b * z)) * c);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (b <= -7.616692883967156e+81)
		tmp = (a * b) * i;
	elseif (b <= -1.0476813589638029e-243)
		tmp = j * (c * t);
	elseif (b <= 21747.96264972048)
		tmp = j * (-i * y);
	else
		tmp = -(b * z) * c;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -7.616692883967156e+81], N[(N[(a * b), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, -1.0476813589638029e-243], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 21747.96264972048], N[(j * N[((-i) * y), $MachinePrecision]), $MachinePrecision], N[((-N[(b * z), $MachinePrecision]) * c), $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 (b <= (217479626497204808401875197887420654296875e-37)) THEN (j * ((- i) * y)) ELSE ((- (b * z)) * c) ENDIF IN
	LET tmp_1 = IF (b <= (-10476813589638029227112553294944263000862225469348245627869577659374035426900854673703016340118715812950282880824913429775934793828177070959866889593130754164658036010482466839275761011921350399394374308856132807502374140180259486087540146347552910458377456375415443614811736021968936942099569278414794165850961502609591144442772584589063226774994429425670034706995683093582695147146913134187662238539174944018083536779852839833910350572027502576045867312734741006778188277897928012215389342041796372098371885871826140072148779301607457384260678242871601863090730499150326202918714901812791140400804579257965087890625e-859)) THEN (j * (c * t)) ELSE tmp_2 ENDIF IN
	LET tmp = IF (b <= (-7616692883967155592851114745475669856004823492955544251737759836127485625939001344)) THEN ((a * b) * i) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if b < -7.6166928839671556e81

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   7. Taylor expanded in y around 0

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

   9. Applied rewrites 22.9%

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

   if -7.6166928839671556e81 < b < -1.0476813589638029e-243

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -1.0476813589638029e-243 < b < 21747.962649720481

   1. Initial program 73.5%

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

   2. Taylor expanded in 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.5%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 21.9%

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

   9. Applied rewrites 21.7%

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

   if 21747.962649720481 < b

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

      \[\leadsto c \cdot \left(j \cdot t - 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 \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 14: 30.2% accurate, 2.6× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -7.966462718214768 \cdot 10^{+64}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;c \leq 2.7674054742742826 \cdot 10^{-47}:\\ \;\;\;\;j \cdot \left(\left(-i\right) \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -7.966462718214768e+64)
  (* j (* c t))
  (if (<= c 2.7674054742742826e-47) (* j (* (- i) y)) (* t (* c 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 <= -7.966462718214768e+64) {
		tmp = j * (c * t);
	} else if (c <= 2.7674054742742826e-47) {
		tmp = j * (-i * y);
	} else {
		tmp = t * (c * 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 <= (-7.966462718214768d+64)) then
        tmp = j * (c * t)
    else if (c <= 2.7674054742742826d-47) then
        tmp = j * (-i * y)
    else
        tmp = t * (c * 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 <= -7.966462718214768e+64) {
		tmp = j * (c * t);
	} else if (c <= 2.7674054742742826e-47) {
		tmp = j * (-i * y);
	} else {
		tmp = t * (c * j);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -7.966462718214768e+64:
		tmp = j * (c * t)
	elif c <= 2.7674054742742826e-47:
		tmp = j * (-i * y)
	else:
		tmp = t * (c * j)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -7.966462718214768e+64)
		tmp = Float64(j * Float64(c * t));
	elseif (c <= 2.7674054742742826e-47)
		tmp = Float64(j * Float64(Float64(-i) * y));
	else
		tmp = Float64(t * Float64(c * j));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -7.966462718214768e+64)
		tmp = j * (c * t);
	elseif (c <= 2.7674054742742826e-47)
		tmp = j * (-i * y);
	else
		tmp = t * (c * j);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -7.966462718214768e+64], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.7674054742742826e-47], N[(j * N[((-i) * y), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * 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 <= (2767405474274282572266594038013135631680437914174999681926008062953482867208676972910036586378455000674621670162870432953250432461800301098264753818511962890625e-206)) THEN (j * ((- i) * y)) ELSE (t * (c * j)) ENDIF IN
	LET tmp = IF (c <= (-79664627182147675644967996496554596347392184082726653827502571520)) THEN (j * (c * t)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -7.9664627182147676e64

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -7.9664627182147676e64 < c < 2.7674054742742826e-47

   1. Initial program 73.5%

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

   2. Taylor expanded in 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.5%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 21.9%

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

   9. Applied rewrites 21.7%

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

   if 2.7674054742742826e-47 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 39.2%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 22.5%

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

Alternative 15: 30.1% accurate, 2.2× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -1.2231746634418026 \cdot 10^{+142}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;c \leq -7.449351102887579 \cdot 10^{-152}:\\ \;\;\;\;\left(a \cdot b\right) \cdot i\\ \mathbf{elif}\;c \leq 2.4315042760271544 \cdot 10^{-46}:\\ \;\;\;\;\left(x \cdot z\right) \cdot y\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -1.2231746634418026e+142)
  (* j (* c t))
  (if (<= c -7.449351102887579e-152)
    (* (* a b) i)
    (if (<= c 2.4315042760271544e-46) (* (* x z) y) (* t (* c 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 <= -1.2231746634418026e+142) {
		tmp = j * (c * t);
	} else if (c <= -7.449351102887579e-152) {
		tmp = (a * b) * i;
	} else if (c <= 2.4315042760271544e-46) {
		tmp = (x * z) * y;
	} else {
		tmp = t * (c * 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 <= (-1.2231746634418026d+142)) then
        tmp = j * (c * t)
    else if (c <= (-7.449351102887579d-152)) then
        tmp = (a * b) * i
    else if (c <= 2.4315042760271544d-46) then
        tmp = (x * z) * y
    else
        tmp = t * (c * 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 <= -1.2231746634418026e+142) {
		tmp = j * (c * t);
	} else if (c <= -7.449351102887579e-152) {
		tmp = (a * b) * i;
	} else if (c <= 2.4315042760271544e-46) {
		tmp = (x * z) * y;
	} else {
		tmp = t * (c * j);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -1.2231746634418026e+142:
		tmp = j * (c * t)
	elif c <= -7.449351102887579e-152:
		tmp = (a * b) * i
	elif c <= 2.4315042760271544e-46:
		tmp = (x * z) * y
	else:
		tmp = t * (c * j)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -1.2231746634418026e+142)
		tmp = Float64(j * Float64(c * t));
	elseif (c <= -7.449351102887579e-152)
		tmp = Float64(Float64(a * b) * i);
	elseif (c <= 2.4315042760271544e-46)
		tmp = Float64(Float64(x * z) * y);
	else
		tmp = Float64(t * Float64(c * j));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -1.2231746634418026e+142)
		tmp = j * (c * t);
	elseif (c <= -7.449351102887579e-152)
		tmp = (a * b) * i;
	elseif (c <= 2.4315042760271544e-46)
		tmp = (x * z) * y;
	else
		tmp = t * (c * j);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -1.2231746634418026e+142], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -7.449351102887579e-152], N[(N[(a * b), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[c, 2.4315042760271544e-46], N[(N[(x * z), $MachinePrecision] * y), $MachinePrecision], N[(t * N[(c * 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_2 = IF (c <= (2431504276027154372088702778097357799533105421310922700008227350802227775896647105673342995170960528607428044811709748340700087965160491876304149627685546875e-202)) THEN ((x * z) * y) ELSE (t * (c * j)) ENDIF IN
	LET tmp_1 = IF (c <= (-74493511028875788355256879195581341247880943895591934244773185442932363679227296187955675492486730117581451276275990932544305914228934681617749121619077262102038664626888561596736322375076615044892502471739931101860670337122500921555994716577216410562222055045199366074204384696802346308656393845065497021134763996256372147856966820909248746209186233315530331644017947301250615055323578417301177978515625e-555)) THEN ((a * b) * i) ELSE tmp_2 ENDIF IN
	LET tmp = IF (c <= (-12231746634418026401908229219405880390642724285308312129430957521477809951450629246983253471596127083709049784771466431118944001151957515370496)) THEN (j * (c * t)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if c < -1.2231746634418026e142

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -1.2231746634418026e142 < c < -7.4493511028875788e-152

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   7. Taylor expanded in y around 0

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

   9. Applied rewrites 22.9%

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

   if -7.4493511028875788e-152 < c < 2.4315042760271544e-46

   1. Initial program 73.5%

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

   2. Taylor expanded in 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.5%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 22.0%

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

   9. Applied rewrites 22.0%

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

   10. Taylor expanded in x around inf

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

   12. Applied rewrites 22.8%

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

   if 2.4315042760271544e-46 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 39.2%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 22.5%

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

Alternative 16: 29.6% accurate, 2.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -1.2231746634418026 \cdot 10^{+142}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;c \leq 1.1040346306123729 \cdot 10^{-95}:\\ \;\;\;\;\left(a \cdot b\right) \cdot i\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -1.2231746634418026e+142)
  (* j (* c t))
  (if (<= c 1.1040346306123729e-95) (* (* a b) i) (* t (* c 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 <= -1.2231746634418026e+142) {
		tmp = j * (c * t);
	} else if (c <= 1.1040346306123729e-95) {
		tmp = (a * b) * i;
	} else {
		tmp = t * (c * 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 <= (-1.2231746634418026d+142)) then
        tmp = j * (c * t)
    else if (c <= 1.1040346306123729d-95) then
        tmp = (a * b) * i
    else
        tmp = t * (c * 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 <= -1.2231746634418026e+142) {
		tmp = j * (c * t);
	} else if (c <= 1.1040346306123729e-95) {
		tmp = (a * b) * i;
	} else {
		tmp = t * (c * j);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	tmp = 0
	if c <= -1.2231746634418026e+142:
		tmp = j * (c * t)
	elif c <= 1.1040346306123729e-95:
		tmp = (a * b) * i
	else:
		tmp = t * (c * j)
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -1.2231746634418026e+142)
		tmp = Float64(j * Float64(c * t));
	elseif (c <= 1.1040346306123729e-95)
		tmp = Float64(Float64(a * b) * i);
	else
		tmp = Float64(t * Float64(c * j));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -1.2231746634418026e+142)
		tmp = j * (c * t);
	elseif (c <= 1.1040346306123729e-95)
		tmp = (a * b) * i;
	else
		tmp = t * (c * j);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -1.2231746634418026e+142], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.1040346306123729e-95], N[(N[(a * b), $MachinePrecision] * i), $MachinePrecision], N[(t * N[(c * 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 <= (1104034630612372872644153373805562147088193948489291104309504173750953257518834094783670986479625088722124384438294727110364549265083889347463686672462075361227735536736196248110691018753290492815942440863853445375420872943055555933343503394183926502591930329799652099609375e-368)) THEN ((a * b) * i) ELSE (t * (c * j)) ENDIF IN
	LET tmp = IF (c <= (-12231746634418026401908229219405880390642724285308312129430957521477809951450629246983253471596127083709049784771466431118944001151957515370496)) THEN (j * (c * t)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -1.2231746634418026e142

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -1.2231746634418026e142 < c < 1.1040346306123729e-95

   1. Initial program 73.5%

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

   2. Taylor expanded in i around -inf

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

   4. Applied rewrites 38.9%

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

   6. Applied rewrites 38.9%

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

   7. Taylor expanded in y around 0

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

   9. Applied rewrites 22.9%

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

   if 1.1040346306123729e-95 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 39.2%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 22.5%

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

Alternative 17: 29.5% accurate, 2.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;c \leq -5.925520682666303 \cdot 10^{+74}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \mathbf{elif}\;c \leq 1.9245857117190567 \cdot 10^{-134}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(c \cdot j\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= c -5.925520682666303e+74)
  (* j (* c t))
  (if (<= c 1.9245857117190567e-134) (* a (* b i)) (* t (* c 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 <= -5.925520682666303e+74) {
		tmp = j * (c * t);
	} else if (c <= 1.9245857117190567e-134) {
		tmp = a * (b * i);
	} else {
		tmp = t * (c * 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 <= (-5.925520682666303d+74)) then
        tmp = j * (c * t)
    else if (c <= 1.9245857117190567d-134) then
        tmp = a * (b * i)
    else
        tmp = t * (c * 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 <= -5.925520682666303e+74) {
		tmp = j * (c * t);
	} else if (c <= 1.9245857117190567e-134) {
		tmp = a * (b * i);
	} else {
		tmp = t * (c * j);
	}
	return tmp;
}

Python

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

Julia

function code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0
	if (c <= -5.925520682666303e+74)
		tmp = Float64(j * Float64(c * t));
	elseif (c <= 1.9245857117190567e-134)
		tmp = Float64(a * Float64(b * i));
	else
		tmp = Float64(t * Float64(c * j));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i, j)
	tmp = 0.0;
	if (c <= -5.925520682666303e+74)
		tmp = j * (c * t);
	elseif (c <= 1.9245857117190567e-134)
		tmp = a * (b * i);
	else
		tmp = t * (c * j);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -5.925520682666303e+74], N[(j * N[(c * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.9245857117190567e-134], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * 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 <= (19245857117190567417362357192002778837991156376832508527380985400313676730063944258054669077245057627125931741454331386247379963458923379995672190867101471785591588312781609604845229605832669653411709270245387518662274787033918521175913341547672960570475404328191464604417848644616893727639367817766963339025395230116378432472235004979665973223745822906494140625e-495)) THEN (a * (b * i)) ELSE (t * (c * j)) ENDIF IN
	LET tmp = IF (c <= (-592552068266630329591769693128954076824076851951469421495498184817297588224)) THEN (j * (c * t)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if c < -5.9255206826663033e74

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -5.9255206826663033e74 < c < 1.9245857117190567e-134

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   7. Taylor expanded in x around 0

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

   9. Applied rewrites 22.8%

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

   if 1.9245857117190567e-134 < c

   1. Initial program 73.5%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 39.2%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 22.5%

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

Alternative 18: 29.2% accurate, 2.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -5797011752.870308:\\ \;\;\;\;c \cdot \left(j \cdot t\right)\\ \mathbf{elif}\;t \leq 2.140768531418191 \cdot 10^{-83}:\\ \;\;\;\;a \cdot \left(b \cdot i\right)\\ \mathbf{else}:\\ \;\;\;\;j \cdot \left(c \cdot t\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c i j)
  :precision binary64
  :pre TRUE
  (if (<= t -5797011752.870308)
  (* c (* j t))
  (if (<= t 2.140768531418191e-83) (* a (* b i)) (* j (* c t)))))

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[t, -5797011752.870308], N[(c * N[(j * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.140768531418191e-83], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t), $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 (t <= (2140768531418191046203145174780752136237934329757633130515302518469433214823617921621304510984622113049317162710626962421684290061647124279333410454515819473417255133758958581498961113823490532551805536932987283904594733030535280704498291015625e-326)) THEN (a * (b * i)) ELSE (j * (c * t)) ENDIF IN
	LET tmp = IF (t <= (-579701175287030792236328125e-17)) THEN (c * (j * t)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -5797011752.8703079

   1. Initial program 73.5%

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

   2. Taylor expanded in c around inf

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

   4. Applied rewrites 38.5%

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

   5. Taylor expanded in z around 0

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

   7. Applied rewrites 22.3%

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

   if -5797011752.8703079 < t < 2.140768531418191e-83

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   7. Taylor expanded in x around 0

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

   9. Applied rewrites 22.8%

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

   if 2.140768531418191e-83 < t

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

Alternative 19: 29.1% accurate, 2.8× speedup

Math

\[\begin{array}{l} t_1 := j \cdot \left(c \cdot t\right)\\ \mathbf{if}\;t \leq -5797011752.870308:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.140768531418191 \cdot 10^{-83}:\\ \;\;\;\;a \cdot \left(b \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 (* j (* c t))))
  (if (<= t -5797011752.870308)
    t_1
    (if (<= t 2.140768531418191e-83) (* a (* b 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 = j * (c * t);
	double tmp;
	if (t <= -5797011752.870308) {
		tmp = t_1;
	} else if (t <= 2.140768531418191e-83) {
		tmp = a * (b * 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 = j * (c * t)
    if (t <= (-5797011752.870308d0)) then
        tmp = t_1
    else if (t <= 2.140768531418191d-83) then
        tmp = a * (b * 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 = j * (c * t);
	double tmp;
	if (t <= -5797011752.870308) {
		tmp = t_1;
	} else if (t <= 2.140768531418191e-83) {
		tmp = a * (b * i);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i, j):
	t_1 = j * (c * t)
	tmp = 0
	if t <= -5797011752.870308:
		tmp = t_1
	elif t <= 2.140768531418191e-83:
		tmp = a * (b * i)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c, i, j)
	t_1 = Float64(j * Float64(c * t))
	tmp = 0.0
	if (t <= -5797011752.870308)
		tmp = t_1;
	elseif (t <= 2.140768531418191e-83)
		tmp = Float64(a * Float64(b * 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 = j * (c * t);
	tmp = 0.0;
	if (t <= -5797011752.870308)
		tmp = t_1;
	elseif (t <= 2.140768531418191e-83)
		tmp = a * (b * 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[(j * N[(c * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5797011752.870308], t$95$1, If[LessEqual[t, 2.140768531418191e-83], N[(a * N[(b * i), $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 * t)) IN
		LET tmp_1 = IF (t <= (2140768531418191046203145174780752136237934329757633130515302518469433214823617921621304510984622113049317162710626962421684290061647124279333410454515819473417255133758958581498961113823490532551805536932987283904594733030535280704498291015625e-326)) THEN (a * (b * i)) ELSE t_1 ENDIF IN
		LET tmp = IF (t <= (-579701175287030792236328125e-17)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -5797011752.8703079 or 2.140768531418191e-83 < t

   1. Initial program 73.5%

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

   2. Taylor expanded in b around 0

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

   4. Applied rewrites 61.1%

      \[\leadsto \mathsf{fma}\left(j, c \cdot t - 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(c \cdot t - i \cdot y\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 38.7%

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

   8. Taylor expanded in y around 0

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

   10. Applied rewrites 22.6%

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

   if -5797011752.8703079 < t < 2.140768531418191e-83

   1. Initial program 73.5%

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

   3. Applied rewrites 75.1%

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

   4. Taylor expanded in a around inf

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

   6. Applied rewrites 39.6%

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

   7. Taylor expanded in x around 0

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

   9. Applied rewrites 22.8%

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

Alternative 20: 22.8% accurate, 5.9× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c, i, j)
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 = a * (b * i)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

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 =
	a * (b * i)
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 - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right) \]
2. Step-by-step derivation

3. Applied rewrites 75.1%

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

4. Taylor expanded in a around inf

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

6. Applied rewrites 39.6%

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

7. Taylor expanded in x around 0

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

9. Applied rewrites 22.8%

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

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t a b c i j)
  :name "Linear.Matrix:det33 from linear-1.19.1.3"
  :precision binary64
  (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))