Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, J

Percentage Accurate: 79.5% → 91.7%

Time: 5.9s

Alternatives: 19

Speedup: 0.8×

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

Specification

Math

\[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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
    code = ((((x * 9.0d0) * y) - (((z * 4.0d0) * t) * a)) + b) / (z * c)
end function

Java

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

Python

def code(x, y, z, t, a, b, c):
	return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c)

Julia

function code(x, y, z, t, a, b, c)
	return Float64(Float64(Float64(Float64(Float64(x * 9.0) * y) - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) / Float64(z * c))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	((((x * (9)) * y) - (((z * (4)) * t) * a)) + b) / (z * c)
END code

Initial Program: 79.5% accurate, 1.0× speedup

Math

\[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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
    code = ((((x * 9.0d0) * y) - (((z * 4.0d0) * t) * a)) + b) / (z * c)
end function

Java

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

Python

def code(x, y, z, t, a, b, c):
	return ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c)

Julia

function code(x, y, z, t, a, b, c)
	return Float64(Float64(Float64(Float64(Float64(x * 9.0) * y) - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) / Float64(z * c))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = ((((x * 9.0) * y) - (((z * 4.0) * t) * a)) + b) / (z * c);
end

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	((((x * (9)) * y) - (((z * (4)) * t) * a)) + b) / (z * c)
END code

Alternative 1: 91.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} t_1 := \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{if}\;z \leq -1.967987986538775 \cdot 10^{-26}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 3.4148850457653397 \cdot 10^{-10}:\\ \;\;\;\;\frac{\mathsf{fma}\left(-9, \mathsf{max}\left(x, y\right) \cdot \mathsf{min}\left(x, y\right), a \cdot \left(t \cdot \left(4 \cdot z\right)\right) - b\right) \cdot \frac{1}{c}}{-z}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (fma
          a
          (* -4.0 t)
          (/ (fma (* (fmax x y) 9.0) (fmin x y) b) z))
         c)))
  (if (<= z -1.967987986538775e-26)
    t_1
    (if (<= z 3.4148850457653397e-10)
      (/
       (*
        (fma
         -9.0
         (* (fmax x y) (fmin x y))
         (- (* a (* t (* 4.0 z))) b))
        (/ 1.0 c))
       (- z))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fma(a, (-4.0 * t), (fma((fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c;
	double tmp;
	if (z <= -1.967987986538775e-26) {
		tmp = t_1;
	} else if (z <= 3.4148850457653397e-10) {
		tmp = (fma(-9.0, (fmax(x, y) * fmin(x, y)), ((a * (t * (4.0 * z))) - b)) * (1.0 / c)) / -z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fma(a, Float64(-4.0 * t), Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c)
	tmp = 0.0
	if (z <= -1.967987986538775e-26)
		tmp = t_1;
	elseif (z <= 3.4148850457653397e-10)
		tmp = Float64(Float64(fma(-9.0, Float64(fmax(x, y) * fmin(x, y)), Float64(Float64(a * Float64(t * Float64(4.0 * z))) - b)) * Float64(1.0 / c)) / Float64(-z));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]}, If[LessEqual[z, -1.967987986538775e-26], t$95$1, If[LessEqual[z, 3.4148850457653397e-10], N[(N[(N[(-9.0 * N[(N[Max[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] + N[(N[(a * N[(t * N[(4.0 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision] * N[(1.0 / c), $MachinePrecision]), $MachinePrecision] / (-z)), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_1 = (((a * ((-4) * t)) + ((((tmp * (9)) * tmp_1) + b) / z)) / c) IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (z <= (34148850457653396950113340273919547429581911046625464223325252532958984375e-83)) THEN (((((-9) * (tmp_6 * tmp_7)) + ((a * (t * ((4) * z))) - b)) * ((1) / c)) / (- z)) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (z <= (-196798798653877496457633139158128790450381324532589120170342172793970410282771155152659048326313495635986328125e-136)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if z < -1.967987986538775e-26 or 3.4148850457653397e-10 < z

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if -1.967987986538775e-26 < z < 3.4148850457653397e-10

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 80.0%

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

Alternative 2: 91.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{if}\;z \leq -138027844.02819937:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.540159892817657 \cdot 10^{-15}:\\ \;\;\;\;\frac{\frac{\mathsf{fma}\left(-9, \mathsf{max}\left(x, y\right) \cdot \mathsf{min}\left(x, y\right), a \cdot \left(t \cdot \left(4 \cdot z\right)\right) - b\right)}{c}}{-z}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (fma
          a
          (* -4.0 t)
          (/ (fma (* (fmax x y) 9.0) (fmin x y) b) z))
         c)))
  (if (<= z -138027844.02819937)
    t_1
    (if (<= z 2.540159892817657e-15)
      (/
       (/
        (fma
         -9.0
         (* (fmax x y) (fmin x y))
         (- (* a (* t (* 4.0 z))) b))
        c)
       (- z))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fma(a, (-4.0 * t), (fma((fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c;
	double tmp;
	if (z <= -138027844.02819937) {
		tmp = t_1;
	} else if (z <= 2.540159892817657e-15) {
		tmp = (fma(-9.0, (fmax(x, y) * fmin(x, y)), ((a * (t * (4.0 * z))) - b)) / c) / -z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fma(a, Float64(-4.0 * t), Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c)
	tmp = 0.0
	if (z <= -138027844.02819937)
		tmp = t_1;
	elseif (z <= 2.540159892817657e-15)
		tmp = Float64(Float64(fma(-9.0, Float64(fmax(x, y) * fmin(x, y)), Float64(Float64(a * Float64(t * Float64(4.0 * z))) - b)) / c) / Float64(-z));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]}, If[LessEqual[z, -138027844.02819937], t$95$1, If[LessEqual[z, 2.540159892817657e-15], N[(N[(N[(-9.0 * N[(N[Max[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] + N[(N[(a * N[(t * N[(4.0 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision] / (-z)), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_1 = (((a * ((-4) * t)) + ((((tmp * (9)) * tmp_1) + b) / z)) / c) IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (z <= (2540159892817657190361678790898946562605933453815598710434642271138727664947509765625e-99)) THEN (((((-9) * (tmp_6 * tmp_7)) + ((a * (t * ((4) * z))) - b)) / c) / (- z)) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (z <= (-138027844028199374675750732421875e-24)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if z < -138027844.02819937 or 2.5401598928176572e-15 < z

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if -138027844.02819937 < z < 2.5401598928176572e-15

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 80.1%

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

Alternative 3: 91.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{if}\;z \leq -1.7678236467301576 \cdot 10^{+33}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 3.4148850457653397 \cdot 10^{-10}:\\ \;\;\;\;\frac{\left(\left(\mathsf{min}\left(x, y\right) \cdot 9\right) \cdot \mathsf{max}\left(x, y\right) - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (fma
          a
          (* -4.0 t)
          (/ (fma (* (fmax x y) 9.0) (fmin x y) b) z))
         c)))
  (if (<= z -1.7678236467301576e+33)
    t_1
    (if (<= z 3.4148850457653397e-10)
      (/
       (+
        (- (* (* (fmin x y) 9.0) (fmax x y)) (* (* (* z 4.0) t) a))
        b)
       (* z c))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fma(a, (-4.0 * t), (fma((fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c;
	double tmp;
	if (z <= -1.7678236467301576e+33) {
		tmp = t_1;
	} else if (z <= 3.4148850457653397e-10) {
		tmp = ((((fmin(x, y) * 9.0) * fmax(x, y)) - (((z * 4.0) * t) * a)) + b) / (z * c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fma(a, Float64(-4.0 * t), Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c)
	tmp = 0.0
	if (z <= -1.7678236467301576e+33)
		tmp = t_1;
	elseif (z <= 3.4148850457653397e-10)
		tmp = Float64(Float64(Float64(Float64(Float64(fmin(x, y) * 9.0) * fmax(x, y)) - Float64(Float64(Float64(z * 4.0) * t) * a)) + b) / Float64(z * c));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]}, If[LessEqual[z, -1.7678236467301576e+33], t$95$1, If[LessEqual[z, 3.4148850457653397e-10], N[(N[(N[(N[(N[(N[Min[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] - N[(N[(N[(z * 4.0), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_1 = (((a * ((-4) * t)) + ((((tmp * (9)) * tmp_1) + b) / z)) / c) IN
		LET tmp_6 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (z <= (34148850457653396950113340273919547429581911046625464223325252532958984375e-83)) THEN (((((tmp_6 * (9)) * tmp_7) - (((z * (4)) * t) * a)) + b) / (z * c)) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (z <= (-1767823646730157566009085307912192)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if z < -1.7678236467301576e33 or 3.4148850457653397e-10 < z

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if -1.7678236467301576e33 < z < 3.4148850457653397e-10

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 91.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{if}\;z \leq -1.2129411278858114 \cdot 10^{-27}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.7571542305423877 \cdot 10^{-11}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a \cdot z, -4 \cdot t, \mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot \mathsf{min}\left(x, y\right), 9, b\right)\right)}{z \cdot c}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (/
         (fma
          a
          (* -4.0 t)
          (/ (fma (* (fmax x y) 9.0) (fmin x y) b) z))
         c)))
  (if (<= z -1.2129411278858114e-27)
    t_1
    (if (<= z 1.7571542305423877e-11)
      (/
       (fma (* a z) (* -4.0 t) (fma (* (fmax x y) (fmin x y)) 9.0 b))
       (* z c))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fma(a, (-4.0 * t), (fma((fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c;
	double tmp;
	if (z <= -1.2129411278858114e-27) {
		tmp = t_1;
	} else if (z <= 1.7571542305423877e-11) {
		tmp = fma((a * z), (-4.0 * t), fma((fmax(x, y) * fmin(x, y)), 9.0, b)) / (z * c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fma(a, Float64(-4.0 * t), Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c)
	tmp = 0.0
	if (z <= -1.2129411278858114e-27)
		tmp = t_1;
	elseif (z <= 1.7571542305423877e-11)
		tmp = Float64(fma(Float64(a * z), Float64(-4.0 * t), fma(Float64(fmax(x, y) * fmin(x, y)), 9.0, b)) / Float64(z * c));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]}, If[LessEqual[z, -1.2129411278858114e-27], t$95$1, If[LessEqual[z, 1.7571542305423877e-11], N[(N[(N[(a * z), $MachinePrecision] * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[Max[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] * 9.0 + b), $MachinePrecision]), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
	LET t_1 = (((a * ((-4) * t)) + ((((tmp * (9)) * tmp_1) + b) / z)) / c) IN
		LET tmp_6 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_5 = IF (z <= (175715423054238771789790562745286529346133708173738341429270803928375244140625e-88)) THEN ((((a * z) * ((-4) * t)) + (((tmp_6 * tmp_7) * (9)) + b)) / (z * c)) ELSE t_1 ENDIF IN
		LET tmp_2 = IF (z <= (-12129411278858114402381036217062463301609953038761475171159392977964324692070896549722647250746376812458038330078125e-142)) THEN t_1 ELSE tmp_5 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if z < -1.2129411278858114e-27 or 1.7571542305423877e-11 < z

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if -1.2129411278858114e-27 < z < 1.7571542305423877e-11

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 79.6%

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

Alternative 5: 89.3% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{max}\left(x, y\right) \cdot 9\\ t_2 := \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(t\_1, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{if}\;z \leq -6.287234288179366 \cdot 10^{-211}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq 2.540159892817657 \cdot 10^{-15}:\\ \;\;\;\;\frac{\mathsf{fma}\left(\mathsf{min}\left(x, y\right), t\_1, \mathsf{fma}\left(-4, \left(a \cdot t\right) \cdot z, b\right)\right)}{z \cdot c}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (fmax x y) 9.0))
       (t_2 (/ (fma a (* -4.0 t) (/ (fma t_1 (fmin x y) b) z)) c)))
  (if (<= z -6.287234288179366e-211)
    t_2
    (if (<= z 2.540159892817657e-15)
      (/ (fma (fmin x y) t_1 (fma -4.0 (* (* a t) z) b)) (* z c))
      t_2))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fmax(x, y) * 9.0;
	double t_2 = fma(a, (-4.0 * t), (fma(t_1, fmin(x, y), b) / z)) / c;
	double tmp;
	if (z <= -6.287234288179366e-211) {
		tmp = t_2;
	} else if (z <= 2.540159892817657e-15) {
		tmp = fma(fmin(x, y), t_1, fma(-4.0, ((a * t) * z), b)) / (z * c);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fmax(x, y) * 9.0)
	t_2 = Float64(fma(a, Float64(-4.0 * t), Float64(fma(t_1, fmin(x, y), b) / z)) / c)
	tmp = 0.0
	if (z <= -6.287234288179366e-211)
		tmp = t_2;
	elseif (z <= 2.540159892817657e-15)
		tmp = Float64(fma(fmin(x, y), t_1, fma(-4.0, Float64(Float64(a * t) * z), b)) / Float64(z * c));
	else
		tmp = t_2;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(t$95$1 * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]}, If[LessEqual[z, -6.287234288179366e-211], t$95$2, If[LessEqual[z, 2.540159892817657e-15], N[(N[(N[Min[x, y], $MachinePrecision] * t$95$1 + N[(-4.0 * N[(N[(a * t), $MachinePrecision] * z), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], t$95$2]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_1 = (tmp * (9)) IN
		LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
		LET t_2 = (((a * ((-4) * t)) + (((t_1 * tmp_1) + b) / z)) / c) IN
			LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_4 = IF (z <= (2540159892817657190361678790898946562605933453815598710434642271138727664947509765625e-99)) THEN (((tmp_5 * t_1) + (((-4) * ((a * t) * z)) + b)) / (z * c)) ELSE t_2 ENDIF IN
			LET tmp_2 = IF (z <= (-6287234288179365880297535913715794680394107579910682498269053360793562357437017130195081656115175998529952011691797047841401289389289849054673421263078428557838614861487402497375025934298484391179977582647256288477189740201488405315531322639503542228885653184467706241657681079310854307842570403847075343866309297660888768943098519529133467866727003577053486096221163265018310958637835891125513621363705425235031154980597592339155965327845103705185244949889838820118742137326920598688187481663602689495318198709128409973345696926116943359375e-751)) THEN t_2 ELSE tmp_4 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if z < -6.2872342881793659e-211 or 2.5401598928176572e-15 < z

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if -6.2872342881793659e-211 < z < 2.5401598928176572e-15

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 80.6%

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

Alternative 6: 86.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq 5.250305942609388 \cdot 10^{+209}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z}\right)}{c}\\ \mathbf{else}:\\ \;\;\;\;a \cdot \left(-4 \cdot \frac{t}{c}\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (if (<= t 5.250305942609388e+209)
  (/ (fma a (* -4.0 t) (/ (fma (* (fmax x y) 9.0) (fmin x y) b) z)) c)
  (* a (* -4.0 (/ t c)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 5.250305942609388e+209) {
		tmp = fma(a, (-4.0 * t), (fma((fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c;
	} else {
		tmp = a * (-4.0 * (t / c));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 5.250305942609388e+209)
		tmp = Float64(fma(a, Float64(-4.0 * t), Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / z)) / c);
	else
		tmp = Float64(a * Float64(-4.0 * Float64(t / c)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 5.250305942609388e+209], N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(a * N[(-4.0 * N[(t / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp_3 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_4 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_2 = IF (t <= (525030594260938772483101241658129840110274458361037733434448741381582634138106647218305200572248387257748176837740928854382441167916678256483597602472228554446550954465258085139310957310966342068607878766264320)) THEN (((a * ((-4) * t)) + ((((tmp_3 * (9)) * tmp_4) + b) / z)) / c) ELSE (a * ((-4) * (t / c))) ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 2 regimes

2. if t < 5.2503059426093877e209

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   if 5.2503059426093877e209 < t

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in a around inf

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

   4. Applied rewrites 67.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto a \cdot \left(-4 \cdot \frac{t}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

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

Alternative 7: 76.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{max}\left(x, y\right) \cdot 9\\ t_2 := \left(\mathsf{min}\left(x, y\right) \cdot 9\right) \cdot \mathsf{max}\left(x, y\right)\\ \mathbf{if}\;t\_2 \leq -5 \cdot 10^{+45}:\\ \;\;\;\;\frac{\mathsf{fma}\left(t\_1, \mathsf{min}\left(x, y\right), b\right)}{z \cdot c}\\ \mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-20}:\\ \;\;\;\;\frac{\mathsf{fma}\left(-4, a \cdot t, 9 \cdot \frac{\mathsf{min}\left(x, y\right) \cdot \mathsf{max}\left(x, y\right)}{z}\right)}{c}\\ \mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+184}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{z} \cdot \frac{t\_1}{c}\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (fmax x y) 9.0))
       (t_2 (* (* (fmin x y) 9.0) (fmax x y))))
  (if (<= t_2 -5e+45)
    (/ (fma t_1 (fmin x y) b) (* z c))
    (if (<= t_2 -1e-20)
      (/ (fma -4.0 (* a t) (* 9.0 (/ (* (fmin x y) (fmax x y)) z))) c)
      (if (<= t_2 5e+184)
        (/ (fma a (* -4.0 t) (/ b z)) c)
        (* (/ (fmin x y) z) (/ t_1 c)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fmax(x, y) * 9.0;
	double t_2 = (fmin(x, y) * 9.0) * fmax(x, y);
	double tmp;
	if (t_2 <= -5e+45) {
		tmp = fma(t_1, fmin(x, y), b) / (z * c);
	} else if (t_2 <= -1e-20) {
		tmp = fma(-4.0, (a * t), (9.0 * ((fmin(x, y) * fmax(x, y)) / z))) / c;
	} else if (t_2 <= 5e+184) {
		tmp = fma(a, (-4.0 * t), (b / z)) / c;
	} else {
		tmp = (fmin(x, y) / z) * (t_1 / c);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fmax(x, y) * 9.0)
	t_2 = Float64(Float64(fmin(x, y) * 9.0) * fmax(x, y))
	tmp = 0.0
	if (t_2 <= -5e+45)
		tmp = Float64(fma(t_1, fmin(x, y), b) / Float64(z * c));
	elseif (t_2 <= -1e-20)
		tmp = Float64(fma(-4.0, Float64(a * t), Float64(9.0 * Float64(Float64(fmin(x, y) * fmax(x, y)) / z))) / c);
	elseif (t_2 <= 5e+184)
		tmp = Float64(fma(a, Float64(-4.0 * t), Float64(b / z)) / c);
	else
		tmp = Float64(Float64(fmin(x, y) / z) * Float64(t_1 / c));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Min[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+45], N[(N[(t$95$1 * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -1e-20], N[(N[(-4.0 * N[(a * t), $MachinePrecision] + N[(9.0 * N[(N[(N[Min[x, y], $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[t$95$2, 5e+184], N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / z), $MachinePrecision] * N[(t$95$1 / c), $MachinePrecision]), $MachinePrecision]]]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_1 = (tmp * (9)) IN
		LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_2 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_2 = ((tmp_1 * (9)) * tmp_2) IN
			LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_9 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_10 = IF (x > y) THEN x ELSE y ENDIF IN
			LET tmp_12 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_11 = IF (t_2 <= (49999999999999998980852208437685758555356472593342082603381605947872422739278055501808572305519799253930125569581478605944175487936819013075944738996003952930215442747098861295896625152)) THEN (((a * ((-4) * t)) + (b / z)) / c) ELSE ((tmp_12 / z) * (t_1 / c)) ENDIF IN
			LET tmp_8 = IF (t_2 <= (-999999999999999945153271454209571651729503702787392447107715776066783064379706047475337982177734375e-119)) THEN ((((-4) * (a * t)) + ((9) * ((tmp_9 * tmp_10) / z))) / c) ELSE tmp_11 ENDIF IN
			LET tmp_4 = IF (t_2 <= (-4999999999999999965699095179735106473829597184)) THEN (((t_1 * tmp_5) + b) / (z * c)) ELSE tmp_8 ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 4 regimes

2. if (*.f64 (*.f64 x #s(literal 9 binary64)) y) < -5e45

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around 0

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   3. Step-by-step derivation

   4. Applied rewrites 60.3%

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   5. Step-by-step derivation

   6. Applied rewrites 60.3%

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

   if -5e45 < (*.f64 (*.f64 x #s(literal 9 binary64)) y) < -9.9999999999999995e-21

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in b around 0

      \[\leadsto \frac{-4 \cdot \left(a \cdot t\right) + 9 \cdot \frac{x \cdot y}{z}}{c} \]
   7. Step-by-step derivation

   8. Applied rewrites 63.6%

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

   if -9.9999999999999995e-21 < (*.f64 (*.f64 x #s(literal 9 binary64)) y) < 4.9999999999999999e184

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in x around 0

      \[\leadsto \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c} \]
   7. Step-by-step derivation

   8. Applied rewrites 63.8%

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

   if 4.9999999999999999e184 < (*.f64 (*.f64 x #s(literal 9 binary64)) y)

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.4%

      \[\leadsto \frac{x}{z} \cdot \frac{y \cdot 9}{c} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 8: 76.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_1 := \left(\mathsf{min}\left(x, y\right) \cdot 9\right) \cdot \mathsf{max}\left(x, y\right)\\ \mathbf{if}\;t\_1 \leq -1 \cdot 10^{-20}:\\ \;\;\;\;\frac{\mathsf{fma}\left(-4 \cdot a, t, \frac{\mathsf{max}\left(x, y\right) \cdot \mathsf{min}\left(x, y\right)}{z} \cdot 9\right)}{c}\\ \mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+184}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{z} \cdot \frac{\mathsf{max}\left(x, y\right) \cdot 9}{c}\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (* (fmin x y) 9.0) (fmax x y))))
  (if (<= t_1 -1e-20)
    (/ (fma (* -4.0 a) t (* (/ (* (fmax x y) (fmin x y)) z) 9.0)) c)
    (if (<= t_1 5e+184)
      (/ (fma a (* -4.0 t) (/ b z)) c)
      (* (/ (fmin x y) z) (/ (* (fmax x y) 9.0) c))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (fmin(x, y) * 9.0) * fmax(x, y);
	double tmp;
	if (t_1 <= -1e-20) {
		tmp = fma((-4.0 * a), t, (((fmax(x, y) * fmin(x, y)) / z) * 9.0)) / c;
	} else if (t_1 <= 5e+184) {
		tmp = fma(a, (-4.0 * t), (b / z)) / c;
	} else {
		tmp = (fmin(x, y) / z) * ((fmax(x, y) * 9.0) / c);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(fmin(x, y) * 9.0) * fmax(x, y))
	tmp = 0.0
	if (t_1 <= -1e-20)
		tmp = Float64(fma(Float64(-4.0 * a), t, Float64(Float64(Float64(fmax(x, y) * fmin(x, y)) / z) * 9.0)) / c);
	elseif (t_1 <= 5e+184)
		tmp = Float64(fma(a, Float64(-4.0 * t), Float64(b / z)) / c);
	else
		tmp = Float64(Float64(fmin(x, y) / z) * Float64(Float64(fmax(x, y) * 9.0) / c));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(N[Min[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-20], N[(N[(N[(-4.0 * a), $MachinePrecision] * t + N[(N[(N[(N[Max[x, y], $MachinePrecision] * N[Min[x, y], $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision] * 9.0), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[t$95$1, 5e+184], N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / z), $MachinePrecision] * N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_1 = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_1 = ((tmp * (9)) * tmp_1) IN
		LET tmp_5 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_6 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_8 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_9 = IF (x > y) THEN x ELSE y ENDIF IN
		LET tmp_7 = IF (t_1 <= (49999999999999998980852208437685758555356472593342082603381605947872422739278055501808572305519799253930125569581478605944175487936819013075944738996003952930215442747098861295896625152)) THEN (((a * ((-4) * t)) + (b / z)) / c) ELSE ((tmp_8 / z) * ((tmp_9 * (9)) / c)) ENDIF IN
		LET tmp_4 = IF (t_1 <= (-999999999999999945153271454209571651729503702787392447107715776066783064379706047475337982177734375e-119)) THEN (((((-4) * a) * t) + (((tmp_5 * tmp_6) / z) * (9))) / c) ELSE tmp_7 ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 x #s(literal 9 binary64)) y) < -9.9999999999999995e-21

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in b around 0

      \[\leadsto \frac{-4 \cdot \left(a \cdot t\right) + 9 \cdot \frac{x \cdot y}{z}}{c} \]
   7. Step-by-step derivation

   8. Applied rewrites 63.6%

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

   10. Applied rewrites 64.1%

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

   if -9.9999999999999995e-21 < (*.f64 (*.f64 x #s(literal 9 binary64)) y) < 4.9999999999999999e184

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in x around 0

      \[\leadsto \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c} \]
   7. Step-by-step derivation

   8. Applied rewrites 63.8%

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

   if 4.9999999999999999e184 < (*.f64 (*.f64 x #s(literal 9 binary64)) y)

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.4%

      \[\leadsto \frac{x}{z} \cdot \frac{y \cdot 9}{c} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 9: 76.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{max}\left(x, y\right) \cdot 9\\ t_2 := \left(\mathsf{min}\left(x, y\right) \cdot 9\right) \cdot \mathsf{max}\left(x, y\right)\\ \mathbf{if}\;t\_2 \leq -5 \cdot 10^{+45}:\\ \;\;\;\;\frac{\mathsf{fma}\left(t\_1, \mathsf{min}\left(x, y\right), b\right)}{z \cdot c}\\ \mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+184}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{min}\left(x, y\right)}{z} \cdot \frac{t\_1}{c}\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (fmax x y) 9.0))
       (t_2 (* (* (fmin x y) 9.0) (fmax x y))))
  (if (<= t_2 -5e+45)
    (/ (fma t_1 (fmin x y) b) (* z c))
    (if (<= t_2 5e+184)
      (/ (fma a (* -4.0 t) (/ b z)) c)
      (* (/ (fmin x y) z) (/ t_1 c))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = fmax(x, y) * 9.0;
	double t_2 = (fmin(x, y) * 9.0) * fmax(x, y);
	double tmp;
	if (t_2 <= -5e+45) {
		tmp = fma(t_1, fmin(x, y), b) / (z * c);
	} else if (t_2 <= 5e+184) {
		tmp = fma(a, (-4.0 * t), (b / z)) / c;
	} else {
		tmp = (fmin(x, y) / z) * (t_1 / c);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(fmax(x, y) * 9.0)
	t_2 = Float64(Float64(fmin(x, y) * 9.0) * fmax(x, y))
	tmp = 0.0
	if (t_2 <= -5e+45)
		tmp = Float64(fma(t_1, fmin(x, y), b) / Float64(z * c));
	elseif (t_2 <= 5e+184)
		tmp = Float64(fma(a, Float64(-4.0 * t), Float64(b / z)) / c);
	else
		tmp = Float64(Float64(fmin(x, y) / z) * Float64(t_1 / c));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Min[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Max[x, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+45], N[(N[(t$95$1 * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e+184], N[(N[(a * N[(-4.0 * t), $MachinePrecision] + N[(b / z), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], N[(N[(N[Min[x, y], $MachinePrecision] / z), $MachinePrecision] * N[(t$95$1 / c), $MachinePrecision]), $MachinePrecision]]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (x > y) THEN x ELSE y ENDIF IN
	LET t_1 = (tmp * (9)) IN
		LET tmp_1 = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_2 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_2 = ((tmp_1 * (9)) * tmp_2) IN
			LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_7 = IF (x < y) THEN x ELSE y ENDIF IN
			LET tmp_6 = IF (t_2 <= (49999999999999998980852208437685758555356472593342082603381605947872422739278055501808572305519799253930125569581478605944175487936819013075944738996003952930215442747098861295896625152)) THEN (((a * ((-4) * t)) + (b / z)) / c) ELSE ((tmp_7 / z) * (t_1 / c)) ENDIF IN
			LET tmp_4 = IF (t_2 <= (-4999999999999999965699095179735106473829597184)) THEN (((t_1 * tmp_5) + b) / (z * c)) ELSE tmp_6 ENDIF IN
	tmp_4
END code

Derivation

1. Split input into 3 regimes

2. if (*.f64 (*.f64 x #s(literal 9 binary64)) y) < -5e45

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around 0

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   3. Step-by-step derivation

   4. Applied rewrites 60.3%

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   5. Step-by-step derivation

   6. Applied rewrites 60.3%

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

   if -5e45 < (*.f64 (*.f64 x #s(literal 9 binary64)) y) < 4.9999999999999999e184

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.9%

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in x around 0

      \[\leadsto \frac{\mathsf{fma}\left(a, -4 \cdot t, \frac{b}{z}\right)}{c} \]
   7. Step-by-step derivation

   8. Applied rewrites 63.8%

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

   if 4.9999999999999999e184 < (*.f64 (*.f64 x #s(literal 9 binary64)) y)

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   5. Step-by-step derivation

   6. Applied rewrites 37.4%

      \[\leadsto \frac{x}{z} \cdot \frac{y \cdot 9}{c} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 64.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -1.0680710456319335 \cdot 10^{+234}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{elif}\;t \leq 9.333995899608361 \cdot 10^{+132}:\\ \;\;\;\;\frac{\mathsf{fma}\left(\mathsf{max}\left(x, y\right) \cdot 9, \mathsf{min}\left(x, y\right), b\right)}{z \cdot c}\\ \mathbf{else}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (if (<= t -1.0680710456319335e+234)
  (* -4.0 (/ (* a t) c))
  (if (<= t 9.333995899608361e+132)
    (/ (fma (* (fmax x y) 9.0) (fmin x y) b) (* z c))
    (* t (* -4.0 (/ a c))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -1.0680710456319335e+234) {
		tmp = -4.0 * ((a * t) / c);
	} else if (t <= 9.333995899608361e+132) {
		tmp = fma((fmax(x, y) * 9.0), fmin(x, y), b) / (z * c);
	} else {
		tmp = t * (-4.0 * (a / c));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= -1.0680710456319335e+234)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	elseif (t <= 9.333995899608361e+132)
		tmp = Float64(fma(Float64(fmax(x, y) * 9.0), fmin(x, y), b) / Float64(z * c));
	else
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, -1.0680710456319335e+234], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.333995899608361e+132], N[(N[(N[(N[Max[x, y], $MachinePrecision] * 9.0), $MachinePrecision] * N[Min[x, y], $MachinePrecision] + b), $MachinePrecision] / N[(z * c), $MachinePrecision]), $MachinePrecision], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp_4 = IF (x > y) THEN x ELSE y ENDIF IN
	LET tmp_5 = IF (x < y) THEN x ELSE y ENDIF IN
	LET tmp_3 = IF (t <= (9333995899608361373273539935623315150375022737689268573042344830793419749098135516788373183751929683313601357929107009099385251299328)) THEN ((((tmp_4 * (9)) * tmp_5) + b) / (z * c)) ELSE (t * ((-4) * (a / c))) ENDIF IN
	LET tmp = IF (t <= (-1068071045631933519887510592451800503968842602509127292963993176363358426381434408029452881628700978623750000806400116464946730937017575981940718354670391978098877573848460645290532863654417408907537663430462570526174324408587084890112)) THEN ((-4) * ((a * t) / c)) ELSE tmp_3 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -1.0680710456319335e234

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]

   if -1.0680710456319335e234 < t < 9.3339958996083614e132

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around 0

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   3. Step-by-step derivation

   4. Applied rewrites 60.3%

      \[\leadsto \frac{b + 9 \cdot \left(x \cdot y\right)}{z \cdot c} \]
   5. Step-by-step derivation

   6. Applied rewrites 60.3%

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

   if 9.3339958996083614e132 < t

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

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

Alternative 11: 50.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := \frac{b}{c} \cdot \frac{1}{z}\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 1.5178565291499546 \cdot 10^{-193}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \mathbf{elif}\;b \leq 1.4805464230991037 \cdot 10^{-119}:\\ \;\;\;\;9 \cdot \frac{x \cdot y}{c \cdot z}\\ \mathbf{elif}\;b \leq 2.708198214512145 \cdot 10^{+21}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{elif}\;b \leq 7.358980364140101 \cdot 10^{+106}:\\ \;\;\;\;y \cdot \left(\frac{x}{c \cdot z} \cdot 9\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ b c) (/ 1.0 z))))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b 1.5178565291499546e-193)
      (* t (* -4.0 (/ a c)))
      (if (<= b 1.4805464230991037e-119)
        (* 9.0 (/ (* x y) (* c z)))
        (if (<= b 2.708198214512145e+21)
          (* -4.0 (/ (* a t) c))
          (if (<= b 7.358980364140101e+106)
            (* y (* (/ x (* c z)) 9.0))
            t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 1.4805464230991037e-119) {
		tmp = 9.0 * ((x * y) / (c * z));
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 7.358980364140101e+106) {
		tmp = y * ((x / (c * z)) * 9.0);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: tmp
    t_1 = (b / c) * (1.0d0 / z)
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= 1.5178565291499546d-193) then
        tmp = t * ((-4.0d0) * (a / c))
    else if (b <= 1.4805464230991037d-119) then
        tmp = 9.0d0 * ((x * y) / (c * z))
    else if (b <= 2.708198214512145d+21) then
        tmp = (-4.0d0) * ((a * t) / c)
    else if (b <= 7.358980364140101d+106) then
        tmp = y * ((x / (c * z)) * 9.0d0)
    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 t_1 = (b / c) * (1.0 / z);
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 1.4805464230991037e-119) {
		tmp = 9.0 * ((x * y) / (c * z));
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 7.358980364140101e+106) {
		tmp = y * ((x / (c * z)) * 9.0);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) * (1.0 / z)
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= 1.5178565291499546e-193:
		tmp = t * (-4.0 * (a / c))
	elif b <= 1.4805464230991037e-119:
		tmp = 9.0 * ((x * y) / (c * z))
	elif b <= 2.708198214512145e+21:
		tmp = -4.0 * ((a * t) / c)
	elif b <= 7.358980364140101e+106:
		tmp = y * ((x / (c * z)) * 9.0)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) * Float64(1.0 / z))
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	elseif (b <= 1.4805464230991037e-119)
		tmp = Float64(9.0 * Float64(Float64(x * y) / Float64(c * z)));
	elseif (b <= 2.708198214512145e+21)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	elseif (b <= 7.358980364140101e+106)
		tmp = Float64(y * Float64(Float64(x / Float64(c * z)) * 9.0));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) * (1.0 / z);
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = t * (-4.0 * (a / c));
	elseif (b <= 1.4805464230991037e-119)
		tmp = 9.0 * ((x * y) / (c * z));
	elseif (b <= 2.708198214512145e+21)
		tmp = -4.0 * ((a * t) / c);
	elseif (b <= 7.358980364140101e+106)
		tmp = y * ((x / (c * z)) * 9.0);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, 1.5178565291499546e-193], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4805464230991037e-119], N[(9.0 * N[(N[(x * y), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.708198214512145e+21], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7.358980364140101e+106], N[(y * N[(N[(x / N[(c * z), $MachinePrecision]), $MachinePrecision] * 9.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) * ((1) / z)) IN
		LET tmp_4 = IF (b <= (73589803641401014029960211531715496922085623798431152290261361744029310148725088236736982701292621404307456)) THEN (y * ((x / (c * z)) * (9))) ELSE t_1 ENDIF IN
		LET tmp_3 = IF (b <= (2708198214512144809984)) THEN ((-4) * ((a * t) / c)) ELSE tmp_4 ENDIF IN
		LET tmp_2 = IF (b <= (1480546423099103722979061291416517626401505970084796801155307355090615515113283261476248085516320622573201604360209407223617477398834779388598147293610685751392587914403292600142733212048361919058530305695409190790375249061096767723668951756550572501237063194911135877357652176645533823907963100197093808674253523349761962890625e-446)) THEN ((9) * ((x * y) / (c * z))) ELSE tmp_3 ENDIF IN
		LET tmp_1 = IF (b <= (1517856529149954555826485218436206495850166695499659120293822806589911972136299906510502703538028835601866161132848550165224269661526870601924672064692513821374007533452514296428289563650269012569048816308010173212660794362889951678428008498241267473223727548226820665928287779268422999223832537397238837990649026378886306729527944347403563274252405406233699941280922962844785290520268579702452774529752642886402481347926960776861857691221026557939759063335649624804091217811219394207000732421875e-688)) THEN (t * ((-4) * (a / c))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 5 regimes

2. if b < -7.0149899965286476e136 or 7.3589803641401014e106 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 34.9%

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]

   if -7.0149899965286476e136 < b < 1.5178565291499546e-193

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]

   if 1.5178565291499546e-193 < b < 1.4805464230991037e-119

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]

   if 1.4805464230991037e-119 < b < 2.7081982145121448e21

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]

   if 2.7081982145121448e21 < b < 7.3589803641401014e106

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   5. Step-by-step derivation

   6. Applied rewrites 38.6%

      \[\leadsto y \cdot \left(\frac{x}{c \cdot z} \cdot 9\right) \]
3. Recombined 5 regimes into one program.
4. Add Preprocessing

Alternative 12: 50.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := \frac{b}{c} \cdot \frac{1}{z}\\ t_2 := 9 \cdot \frac{x \cdot y}{c \cdot z}\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 1.5178565291499546 \cdot 10^{-193}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \mathbf{elif}\;b \leq 1.4805464230991037 \cdot 10^{-119}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 2.708198214512145 \cdot 10^{+21}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{elif}\;b \leq 3.489769900108028 \cdot 10^{+66}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ b c) (/ 1.0 z))) (t_2 (* 9.0 (/ (* x y) (* c z)))))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b 1.5178565291499546e-193)
      (* t (* -4.0 (/ a c)))
      (if (<= b 1.4805464230991037e-119)
        t_2
        (if (<= b 2.708198214512145e+21)
          (* -4.0 (/ (* a t) c))
          (if (<= b 3.489769900108028e+66) t_2 t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double t_2 = 9.0 * ((x * y) / (c * z));
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 1.4805464230991037e-119) {
		tmp = t_2;
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 3.489769900108028e+66) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (b / c) * (1.0d0 / z)
    t_2 = 9.0d0 * ((x * y) / (c * z))
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= 1.5178565291499546d-193) then
        tmp = t * ((-4.0d0) * (a / c))
    else if (b <= 1.4805464230991037d-119) then
        tmp = t_2
    else if (b <= 2.708198214512145d+21) then
        tmp = (-4.0d0) * ((a * t) / c)
    else if (b <= 3.489769900108028d+66) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double t_2 = 9.0 * ((x * y) / (c * z));
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 1.4805464230991037e-119) {
		tmp = t_2;
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 3.489769900108028e+66) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) * (1.0 / z)
	t_2 = 9.0 * ((x * y) / (c * z))
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= 1.5178565291499546e-193:
		tmp = t * (-4.0 * (a / c))
	elif b <= 1.4805464230991037e-119:
		tmp = t_2
	elif b <= 2.708198214512145e+21:
		tmp = -4.0 * ((a * t) / c)
	elif b <= 3.489769900108028e+66:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) * Float64(1.0 / z))
	t_2 = Float64(9.0 * Float64(Float64(x * y) / Float64(c * z)))
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	elseif (b <= 1.4805464230991037e-119)
		tmp = t_2;
	elseif (b <= 2.708198214512145e+21)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	elseif (b <= 3.489769900108028e+66)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) * (1.0 / z);
	t_2 = 9.0 * ((x * y) / (c * z));
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = t * (-4.0 * (a / c));
	elseif (b <= 1.4805464230991037e-119)
		tmp = t_2;
	elseif (b <= 2.708198214512145e+21)
		tmp = -4.0 * ((a * t) / c);
	elseif (b <= 3.489769900108028e+66)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(9.0 * N[(N[(x * y), $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, 1.5178565291499546e-193], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4805464230991037e-119], t$95$2, If[LessEqual[b, 2.708198214512145e+21], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.489769900108028e+66], t$95$2, t$95$1]]]]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) * ((1) / z)) IN
		LET t_2 = ((9) * ((x * y) / (c * z))) IN
			LET tmp_4 = IF (b <= (3489769900108027993671670768357531302462894332595980943235034906624)) THEN t_2 ELSE t_1 ENDIF IN
			LET tmp_3 = IF (b <= (2708198214512144809984)) THEN ((-4) * ((a * t) / c)) ELSE tmp_4 ENDIF IN
			LET tmp_2 = IF (b <= (1480546423099103722979061291416517626401505970084796801155307355090615515113283261476248085516320622573201604360209407223617477398834779388598147293610685751392587914403292600142733212048361919058530305695409190790375249061096767723668951756550572501237063194911135877357652176645533823907963100197093808674253523349761962890625e-446)) THEN t_2 ELSE tmp_3 ENDIF IN
			LET tmp_1 = IF (b <= (1517856529149954555826485218436206495850166695499659120293822806589911972136299906510502703538028835601866161132848550165224269661526870601924672064692513821374007533452514296428289563650269012569048816308010173212660794362889951678428008498241267473223727548226820665928287779268422999223832537397238837990649026378886306729527944347403563274252405406233699941280922962844785290520268579702452774529752642886402481347926960776861857691221026557939759063335649624804091217811219394207000732421875e-688)) THEN (t * ((-4) * (a / c))) ELSE tmp_2 ENDIF IN
			LET tmp = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if b < -7.0149899965286476e136 or 3.489769900108028e66 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 34.9%

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]

   if -7.0149899965286476e136 < b < 1.5178565291499546e-193

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]

   if 1.5178565291499546e-193 < b < 1.4805464230991037e-119 or 2.7081982145121448e21 < b < 3.489769900108028e66

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]

   if 1.4805464230991037e-119 < b < 2.7081982145121448e21

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 13: 50.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \frac{b}{c} \cdot \frac{1}{z}\\ t_2 := 9 \cdot \left(\mathsf{min}\left(x, y\right) \cdot \frac{\mathsf{max}\left(x, y\right)}{c \cdot z}\right)\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 1.5178565291499546 \cdot 10^{-193}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \mathbf{elif}\;b \leq 2.609557643009019 \cdot 10^{-119}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq 2.708198214512145 \cdot 10^{+21}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{elif}\;b \leq 1.0125531955801704 \cdot 10^{+107}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ b c) (/ 1.0 z)))
       (t_2 (* 9.0 (* (fmin x y) (/ (fmax x y) (* c z))))))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b 1.5178565291499546e-193)
      (* t (* -4.0 (/ a c)))
      (if (<= b 2.609557643009019e-119)
        t_2
        (if (<= b 2.708198214512145e+21)
          (* -4.0 (/ (* a t) c))
          (if (<= b 1.0125531955801704e+107) t_2 t_1)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double t_2 = 9.0 * (fmin(x, y) * (fmax(x, y) / (c * z)));
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 2.609557643009019e-119) {
		tmp = t_2;
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 1.0125531955801704e+107) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (b / c) * (1.0d0 / z)
    t_2 = 9.0d0 * (fmin(x, y) * (fmax(x, y) / (c * z)))
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= 1.5178565291499546d-193) then
        tmp = t * ((-4.0d0) * (a / c))
    else if (b <= 2.609557643009019d-119) then
        tmp = t_2
    else if (b <= 2.708198214512145d+21) then
        tmp = (-4.0d0) * ((a * t) / c)
    else if (b <= 1.0125531955801704d+107) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double t_2 = 9.0 * (fmin(x, y) * (fmax(x, y) / (c * z)));
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 1.5178565291499546e-193) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 2.609557643009019e-119) {
		tmp = t_2;
	} else if (b <= 2.708198214512145e+21) {
		tmp = -4.0 * ((a * t) / c);
	} else if (b <= 1.0125531955801704e+107) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) * (1.0 / z)
	t_2 = 9.0 * (fmin(x, y) * (fmax(x, y) / (c * z)))
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= 1.5178565291499546e-193:
		tmp = t * (-4.0 * (a / c))
	elif b <= 2.609557643009019e-119:
		tmp = t_2
	elif b <= 2.708198214512145e+21:
		tmp = -4.0 * ((a * t) / c)
	elif b <= 1.0125531955801704e+107:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) * Float64(1.0 / z))
	t_2 = Float64(9.0 * Float64(fmin(x, y) * Float64(fmax(x, y) / Float64(c * z))))
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	elseif (b <= 2.609557643009019e-119)
		tmp = t_2;
	elseif (b <= 2.708198214512145e+21)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	elseif (b <= 1.0125531955801704e+107)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) * (1.0 / z);
	t_2 = 9.0 * (min(x, y) * (max(x, y) / (c * z)));
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 1.5178565291499546e-193)
		tmp = t * (-4.0 * (a / c));
	elseif (b <= 2.609557643009019e-119)
		tmp = t_2;
	elseif (b <= 2.708198214512145e+21)
		tmp = -4.0 * ((a * t) / c);
	elseif (b <= 1.0125531955801704e+107)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(9.0 * N[(N[Min[x, y], $MachinePrecision] * N[(N[Max[x, y], $MachinePrecision] / N[(c * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, 1.5178565291499546e-193], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.609557643009019e-119], t$95$2, If[LessEqual[b, 2.708198214512145e+21], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.0125531955801704e+107], t$95$2, t$95$1]]]]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) * ((1) / z)) IN
		LET tmp = IF (x < y) THEN x ELSE y ENDIF IN
		LET tmp_1 = IF (x > y) THEN x ELSE y ENDIF IN
		LET t_2 = ((9) * (tmp * (tmp_1 / (c * z)))) IN
			LET tmp_6 = IF (b <= (101255319558017044746851378566173177823930392427726640893772583568288012416165947775983507035137908152467456)) THEN t_2 ELSE t_1 ENDIF IN
			LET tmp_5 = IF (b <= (2708198214512144809984)) THEN ((-4) * ((a * t) / c)) ELSE tmp_6 ENDIF IN
			LET tmp_4 = IF (b <= (2609557643009018847268904670035844029436318306201241893023433988980747618960747446759498205185931607115108933584581711184362048248302273859324124210407356367766864102970697225411238293202447779604983167108443652324744440540888612546077881498367703487356699920435682568821574468818097892845730978450546899694018065929412841796875e-446)) THEN t_2 ELSE tmp_5 ENDIF IN
			LET tmp_3 = IF (b <= (1517856529149954555826485218436206495850166695499659120293822806589911972136299906510502703538028835601866161132848550165224269661526870601924672064692513821374007533452514296428289563650269012569048816308010173212660794362889951678428008498241267473223727548226820665928287779268422999223832537397238837990649026378886306729527944347403563274252405406233699941280922962844785290520268579702452774529752642886402481347926960776861857691221026557939759063335649624804091217811219394207000732421875e-688)) THEN (t * ((-4) * (a / c))) ELSE tmp_4 ENDIF IN
			LET tmp_2 = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_3 ENDIF IN
	tmp_2
END code

Derivation

1. Split input into 4 regimes

2. if b < -7.0149899965286476e136 or 1.0125531955801704e107 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 34.9%

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]

   if -7.0149899965286476e136 < b < 1.5178565291499546e-193

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]

   if 1.5178565291499546e-193 < b < 2.6095576430090188e-119 or 2.7081982145121448e21 < b < 1.0125531955801704e107

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in x around inf

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 36.1%

      \[\leadsto 9 \cdot \frac{x \cdot y}{c \cdot z} \]
   5. Step-by-step derivation

   6. Applied rewrites 38.5%

      \[\leadsto 9 \cdot \left(x \cdot \frac{y}{c \cdot z}\right) \]

   if 2.6095576430090188e-119 < b < 2.7081982145121448e21

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 14: 49.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \frac{b}{c} \cdot \frac{1}{z}\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -1.4056119737213228 \cdot 10^{-281}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \mathbf{elif}\;b \leq 3.489769900108028 \cdot 10^{+66}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ b c) (/ 1.0 z))))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b -1.4056119737213228e-281)
      (* t (* -4.0 (/ a c)))
      (if (<= b 3.489769900108028e+66) (* -4.0 (/ (* a t) c)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= -1.4056119737213228e-281) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: tmp
    t_1 = (b / c) * (1.0d0 / z)
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= (-1.4056119737213228d-281)) then
        tmp = t * ((-4.0d0) * (a / c))
    else if (b <= 3.489769900108028d+66) then
        tmp = (-4.0d0) * ((a * t) / c)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) * (1.0 / z);
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= -1.4056119737213228e-281) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) * (1.0 / z)
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= -1.4056119737213228e-281:
		tmp = t * (-4.0 * (a / c))
	elif b <= 3.489769900108028e+66:
		tmp = -4.0 * ((a * t) / c)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) * Float64(1.0 / z))
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= -1.4056119737213228e-281)
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	elseif (b <= 3.489769900108028e+66)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) * (1.0 / z);
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= -1.4056119737213228e-281)
		tmp = t * (-4.0 * (a / c));
	elseif (b <= 3.489769900108028e+66)
		tmp = -4.0 * ((a * t) / c);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, -1.4056119737213228e-281], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.489769900108028e+66], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) * ((1) / z)) IN
		LET tmp_2 = IF (b <= (3489769900108027993671670768357531302462894332595980943235034906624)) THEN ((-4) * ((a * t) / c)) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (b <= (-1405611973721322796469054560483649194923250423606389683612564121840262823247462555062433727622231678859618357455755263759559720934242459969267164029085550789512205082079457744164866049300736262335286354690355543101742267959085303793153815570782881851899501982866060876891819831871270599800146615623208749206011116256026295220163314847589970659741760286644254062226801563512032166365737173044860216882783783779502627293177018360031038326209127069703336720480540847035888954165299334953251580069676354631660821584691628296560663449521660941557077239943529109116399107833800818813725173450938147260379383383045693952030402007758592616358372878070618814799225095089722781249719218976679258048534393310546875e-983)) THEN (t * ((-4) * (a / c))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -7.0149899965286476e136 or 3.489769900108028e66 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 34.9%

      \[\leadsto \frac{b}{c} \cdot \frac{1}{z} \]

   if -7.0149899965286476e136 < b < -1.4056119737213228e-281

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]

   if -1.4056119737213228e-281 < b < 3.489769900108028e66

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 15: 49.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \frac{\frac{b}{c}}{z}\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq -1.4056119737213228 \cdot 10^{-281}:\\ \;\;\;\;t \cdot \left(-4 \cdot \frac{a}{c}\right)\\ \mathbf{elif}\;b \leq 3.489769900108028 \cdot 10^{+66}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (/ b c) z)))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b -1.4056119737213228e-281)
      (* t (* -4.0 (/ a c)))
      (if (<= b 3.489769900108028e+66) (* -4.0 (/ (* a t) c)) t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= -1.4056119737213228e-281) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: tmp
    t_1 = (b / c) / z
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= (-1.4056119737213228d-281)) then
        tmp = t * ((-4.0d0) * (a / c))
    else if (b <= 3.489769900108028d+66) then
        tmp = (-4.0d0) * ((a * t) / c)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= -1.4056119737213228e-281) {
		tmp = t * (-4.0 * (a / c));
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) / z
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= -1.4056119737213228e-281:
		tmp = t * (-4.0 * (a / c))
	elif b <= 3.489769900108028e+66:
		tmp = -4.0 * ((a * t) / c)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) / z)
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= -1.4056119737213228e-281)
		tmp = Float64(t * Float64(-4.0 * Float64(a / c)));
	elseif (b <= 3.489769900108028e+66)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) / z;
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= -1.4056119737213228e-281)
		tmp = t * (-4.0 * (a / c));
	elseif (b <= 3.489769900108028e+66)
		tmp = -4.0 * ((a * t) / c);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, -1.4056119737213228e-281], N[(t * N[(-4.0 * N[(a / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.489769900108028e+66], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) / z) IN
		LET tmp_2 = IF (b <= (3489769900108027993671670768357531302462894332595980943235034906624)) THEN ((-4) * ((a * t) / c)) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (b <= (-1405611973721322796469054560483649194923250423606389683612564121840262823247462555062433727622231678859618357455755263759559720934242459969267164029085550789512205082079457744164866049300736262335286354690355543101742267959085303793153815570782881851899501982866060876891819831871270599800146615623208749206011116256026295220163314847589970659741760286644254062226801563512032166365737173044860216882783783779502627293177018360031038326209127069703336720480540847035888954165299334953251580069676354631660821584691628296560663449521660941557077239943529109116399107833800818813725173450938147260379383383045693952030402007758592616358372878070618814799225095089722781249719218976679258048534393310546875e-983)) THEN (t * ((-4) * (a / c))) ELSE tmp_2 ENDIF IN
		LET tmp = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -7.0149899965286476e136 or 3.489769900108028e66 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{\frac{b}{c}}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 35.0%

      \[\leadsto \frac{\frac{b}{c}}{z} \]

   if -7.0149899965286476e136 < b < -1.4056119737213228e-281

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 69.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

      \[\leadsto t \cdot \left(-4 \cdot \frac{a}{c}\right) \]

   if -1.4056119737213228e-281 < b < 3.489769900108028e66

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 16: 49.2% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := \frac{\frac{b}{c}}{z}\\ \mathbf{if}\;b \leq -7.014989996528648 \cdot 10^{+136}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 2.9133384393647986 \cdot 10^{+151}:\\ \;\;\;\;a \cdot \left(-4 \cdot \frac{t}{c}\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (/ b c) z)))
  (if (<= b -7.014989996528648e+136)
    t_1
    (if (<= b 2.9133384393647986e+151) (* a (* -4.0 (/ t c))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 2.9133384393647986e+151) {
		tmp = a * (-4.0 * (t / c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: tmp
    t_1 = (b / c) / z
    if (b <= (-7.014989996528648d+136)) then
        tmp = t_1
    else if (b <= 2.9133384393647986d+151) then
        tmp = a * ((-4.0d0) * (t / c))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -7.014989996528648e+136) {
		tmp = t_1;
	} else if (b <= 2.9133384393647986e+151) {
		tmp = a * (-4.0 * (t / c));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) / z
	tmp = 0
	if b <= -7.014989996528648e+136:
		tmp = t_1
	elif b <= 2.9133384393647986e+151:
		tmp = a * (-4.0 * (t / c))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) / z)
	tmp = 0.0
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 2.9133384393647986e+151)
		tmp = Float64(a * Float64(-4.0 * Float64(t / c)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) / z;
	tmp = 0.0;
	if (b <= -7.014989996528648e+136)
		tmp = t_1;
	elseif (b <= 2.9133384393647986e+151)
		tmp = a * (-4.0 * (t / c));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[b, -7.014989996528648e+136], t$95$1, If[LessEqual[b, 2.9133384393647986e+151], N[(a * N[(-4.0 * N[(t / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) / z) IN
		LET tmp_1 = IF (b <= (29133384393647986121420706735237066204707828924739787220670821966701292858695836331568370245017220531887321702841871801728140459945521960259815817084928)) THEN (a * ((-4) * (t / c))) ELSE t_1 ENDIF IN
		LET tmp = IF (b <= (-70149899965286476121874498915152866176819237656087046600362415541277254843654413389083362023762781255257553942235249895354531706923122688)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if b < -7.0149899965286476e136 or 2.9133384393647986e151 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{\frac{b}{c}}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 35.0%

      \[\leadsto \frac{\frac{b}{c}}{z} \]

   if -7.0149899965286476e136 < b < 2.9133384393647986e151

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in a around inf

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

   4. Applied rewrites 67.7%

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

   5. Taylor expanded in z around inf

      \[\leadsto a \cdot \left(-4 \cdot \frac{t}{c}\right) \]
   6. Step-by-step derivation

   7. Applied rewrites 40.0%

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

Alternative 17: 49.2% accurate, 1.5× speedup

Math

\[\begin{array}{l} t_1 := \frac{\frac{b}{c}}{z}\\ \mathbf{if}\;b \leq -2.8237281227165254 \cdot 10^{-12}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 3.489769900108028 \cdot 10^{+66}:\\ \;\;\;\;-4 \cdot \frac{a \cdot t}{c}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (/ b c) z)))
  (if (<= b -2.8237281227165254e-12)
    t_1
    (if (<= b 3.489769900108028e+66) (* -4.0 (/ (* a t) c)) t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -2.8237281227165254e-12) {
		tmp = t_1;
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
    real(8) :: tmp
    t_1 = (b / c) / z
    if (b <= (-2.8237281227165254d-12)) then
        tmp = t_1
    else if (b <= 3.489769900108028d+66) then
        tmp = (-4.0d0) * ((a * t) / c)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (b / c) / z;
	double tmp;
	if (b <= -2.8237281227165254e-12) {
		tmp = t_1;
	} else if (b <= 3.489769900108028e+66) {
		tmp = -4.0 * ((a * t) / c);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (b / c) / z
	tmp = 0
	if b <= -2.8237281227165254e-12:
		tmp = t_1
	elif b <= 3.489769900108028e+66:
		tmp = -4.0 * ((a * t) / c)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(b / c) / z)
	tmp = 0.0
	if (b <= -2.8237281227165254e-12)
		tmp = t_1;
	elseif (b <= 3.489769900108028e+66)
		tmp = Float64(-4.0 * Float64(Float64(a * t) / c));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (b / c) / z;
	tmp = 0.0;
	if (b <= -2.8237281227165254e-12)
		tmp = t_1;
	elseif (b <= 3.489769900108028e+66)
		tmp = -4.0 * ((a * t) / c);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision]}, If[LessEqual[b, -2.8237281227165254e-12], t$95$1, If[LessEqual[b, 3.489769900108028e+66], N[(-4.0 * N[(N[(a * t), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET t_1 = ((b / c) / z) IN
		LET tmp_1 = IF (b <= (3489769900108027993671670768357531302462894332595980943235034906624)) THEN ((-4) * ((a * t) / c)) ELSE t_1 ENDIF IN
		LET tmp = IF (b <= (-28237281227165253616122598090154119138302235558768416012753732502460479736328125e-91)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if b < -2.8237281227165254e-12 or 3.489769900108028e66 < b

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{\frac{b}{c}}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 35.0%

      \[\leadsto \frac{\frac{b}{c}}{z} \]

   if -2.8237281227165254e-12 < b < 3.489769900108028e66

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in z around inf

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
   3. Step-by-step derivation

   4. Applied rewrites 38.4%

      \[\leadsto -4 \cdot \frac{a \cdot t}{c} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 35.3% accurate, 2.3× speedup

Math

\[\begin{array}{l} \mathbf{if}\;a \leq -4.993291987525573 \cdot 10^{-201}:\\ \;\;\;\;\frac{\frac{b}{c}}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{b}{c \cdot z}\\ \end{array} \]

FPCore

(FPCore (x y z t a b c)
  :precision binary64
  :pre TRUE
  (if (<= a -4.993291987525573e-201) (/ (/ b c) z) (/ b (* c z))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (a <= -4.993291987525573e-201) {
		tmp = (b / c) / z;
	} else {
		tmp = b / (c * z);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
    if (a <= (-4.993291987525573d-201)) then
        tmp = (b / c) / z
    else
        tmp = b / (c * 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 tmp;
	if (a <= -4.993291987525573e-201) {
		tmp = (b / c) / z;
	} else {
		tmp = b / (c * z);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if a <= -4.993291987525573e-201:
		tmp = (b / c) / z
	else:
		tmp = b / (c * z)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (a <= -4.993291987525573e-201)
		tmp = Float64(Float64(b / c) / z);
	else
		tmp = Float64(b / Float64(c * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (a <= -4.993291987525573e-201)
		tmp = (b / c) / z;
	else
		tmp = b / (c * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[a, -4.993291987525573e-201], N[(N[(b / c), $MachinePrecision] / z), $MachinePrecision], N[(b / N[(c * z), $MachinePrecision]), $MachinePrecision]]

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	LET tmp = IF (a <= (-49932919875255732086075609011438270192926133394304847018607502512745088774756160263062781154132641976275515702498334786669189802129403194060122742713644275010650719830748501478743127224456641963389533565528592321471595190875569003917348136144834091127267155357726833366081850823453706556982527734015339065277612316601091834408455470872065049248501829538972908497381192625088524473450173200229602181444659724601348167315678500365774310612629505832066609145715468748147057337534449050764351341058500111103057861328125e-715)) THEN ((b / c) / z) ELSE (b / (c * z)) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if a < -4.9932919875255732e-201

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]
   2. Step-by-step derivation

   3. Applied rewrites 81.0%

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

   4. Taylor expanded in b around inf

      \[\leadsto \frac{\frac{b}{c}}{z} \]
   5. Step-by-step derivation

   6. Applied rewrites 35.0%

      \[\leadsto \frac{\frac{b}{c}}{z} \]

   if -4.9932919875255732e-201 < a

   1. Initial program 79.5%

      \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

   2. Taylor expanded in b around inf

      \[\leadsto \frac{b}{c \cdot z} \]
   3. Step-by-step derivation

   4. Applied rewrites 35.3%

      \[\leadsto \frac{b}{c \cdot z} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 19: 35.2% accurate, 3.6× speedup

Math

\[\frac{b}{c \cdot z} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t, a, b, c):
	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]
code: THEORY
BEGIN
f(x, y, z, t, a, b, c: real): real =
	b / (c * z)
END code

Derivation

1. Initial program 79.5%

   \[\frac{\left(\left(x \cdot 9\right) \cdot y - \left(\left(z \cdot 4\right) \cdot t\right) \cdot a\right) + b}{z \cdot c} \]

2. Taylor expanded in b around inf

   \[\leadsto \frac{b}{c \cdot z} \]
3. Step-by-step derivation

4. Applied rewrites 35.3%

   \[\leadsto \frac{b}{c \cdot z} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t a b c)
  :name "Diagrams.Solve.Polynomial:cubForm  from diagrams-solve-0.1, J"
  :precision binary64
  (/ (+ (- (* (* x 9.0) y) (* (* (* z 4.0) t) a)) b) (* z c)))