Development.Shake.Progress:decay from shake-0.15.5

Percentage Accurate: 65.9% → 84.6%

Time: 6.1s

Alternatives: 16

Speedup: 1.3×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

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

Initial Program: 65.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

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

Alternative 1: 84.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -26604015212521447000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 3.123793870007829 \cdot 10^{+27}:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -26604015212521447000.0)
    t_1
    (if (<= z 3.123793870007829e+27)
      (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y))))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -26604015212521447000.0) {
		tmp = t_1;
	} else if (z <= 3.123793870007829e+27) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-26604015212521447000.0d0)) then
        tmp = t_1
    else if (z <= 3.123793870007829d+27) then
        tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -26604015212521447000.0) {
		tmp = t_1;
	} else if (z <= 3.123793870007829e+27) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -26604015212521447000.0:
		tmp = t_1
	elif z <= 3.123793870007829e+27:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -26604015212521447000.0)
		tmp = t_1;
	elseif (z <= 3.123793870007829e+27)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * Float64(b - y))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -26604015212521447000.0)
		tmp = t_1;
	elseif (z <= 3.123793870007829e+27)
		tmp = ((x * y) + (z * (t - a))) / (y + (z * (b - y)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -26604015212521447000.0], t$95$1, If[LessEqual[z, 3.123793870007829e+27], N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if z < -26604015212521447000 or 3.1237938700078292e27 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -26604015212521447000 < z < 3.1237938700078292e27

   1. Initial program 65.9%

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

Alternative 2: 84.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -26604015212521447000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 3.123793870007829 \cdot 10^{+27}:\\ \;\;\;\;\frac{\mathsf{fma}\left(t - a, z, y \cdot x\right)}{\mathsf{fma}\left(b - y, z, y\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -26604015212521447000.0)
    t_1
    (if (<= z 3.123793870007829e+27)
      (/ (fma (- t a) z (* y x)) (fma (- b y) z y))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -26604015212521447000.0) {
		tmp = t_1;
	} else if (z <= 3.123793870007829e+27) {
		tmp = fma((t - a), z, (y * x)) / fma((b - y), z, y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -26604015212521447000.0)
		tmp = t_1;
	elseif (z <= 3.123793870007829e+27)
		tmp = Float64(fma(Float64(t - a), z, Float64(y * x)) / fma(Float64(b - y), z, y));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -26604015212521447000.0], t$95$1, If[LessEqual[z, 3.123793870007829e+27], N[(N[(N[(t - a), $MachinePrecision] * z + N[(y * x), $MachinePrecision]), $MachinePrecision] / N[(N[(b - y), $MachinePrecision] * z + y), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if z < -26604015212521447000 or 3.1237938700078292e27 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -26604015212521447000 < z < 3.1237938700078292e27

   1. Initial program 65.9%

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

   3. Applied rewrites 65.9%

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

Alternative 3: 83.3% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -190874466332.14713:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 957920277915947400:\\ \;\;\;\;\frac{x \cdot y + z \cdot \left(t - a\right)}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -190874466332.14713)
    t_1
    (if (<= z 957920277915947400.0)
      (/ (+ (* x y) (* z (- t a))) (+ y (* z b)))
      t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -190874466332.14713) {
		tmp = t_1;
	} else if (z <= 957920277915947400.0) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-190874466332.14713d0)) then
        tmp = t_1
    else if (z <= 957920277915947400.0d0) then
        tmp = ((x * y) + (z * (t - a))) / (y + (z * b))
    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 t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -190874466332.14713) {
		tmp = t_1;
	} else if (z <= 957920277915947400.0) {
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -190874466332.14713:
		tmp = t_1
	elif z <= 957920277915947400.0:
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -190874466332.14713)
		tmp = t_1;
	elseif (z <= 957920277915947400.0)
		tmp = Float64(Float64(Float64(x * y) + Float64(z * Float64(t - a))) / Float64(y + Float64(z * b)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -190874466332.14713)
		tmp = t_1;
	elseif (z <= 957920277915947400.0)
		tmp = ((x * y) + (z * (t - a))) / (y + (z * b));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -190874466332.14713], t$95$1, If[LessEqual[z, 957920277915947400.0], N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / (b - y)) IN
		LET tmp_1 = IF (z <= (957920277915947392)) THEN (((x * y) + (z * (t - a))) / (y + (z * b))) ELSE t_1 ENDIF IN
		LET tmp = IF (z <= (-190874466332147125244140625e-15)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -190874466332.14713 or 957920277915947390 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -190874466332.14713 < z < 957920277915947390

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 56.1%

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

Alternative 4: 75.1% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq 4.453155276752717 \cdot 10^{-161}:\\ \;\;\;\;\frac{\mathsf{fma}\left(t, z, x \cdot y\right)}{y + z \cdot \left(b - y\right)}\\ \mathbf{elif}\;z \leq 2.0606006390105884 \cdot 10^{-12}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right)}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b - y} - \frac{a}{b - y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (if (<= z -5.346553857333096e-17)
  (/ (- t a) (- b y))
  (if (<= z 4.453155276752717e-161)
    (/ (fma t z (* x y)) (+ y (* z (- b y))))
    (if (<= z 2.0606006390105884e-12)
      (/ (* z (- t a)) (+ y (* z b)))
      (- (/ t (- b y)) (/ a (- b y)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = (t - a) / (b - y);
	} else if (z <= 4.453155276752717e-161) {
		tmp = fma(t, z, (x * y)) / (y + (z * (b - y)));
	} else if (z <= 2.0606006390105884e-12) {
		tmp = (z * (t - a)) / (y + (z * b));
	} else {
		tmp = (t / (b - y)) - (a / (b - y));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = Float64(Float64(t - a) / Float64(b - y));
	elseif (z <= 4.453155276752717e-161)
		tmp = Float64(fma(t, z, Float64(x * y)) / Float64(y + Float64(z * Float64(b - y))));
	elseif (z <= 2.0606006390105884e-12)
		tmp = Float64(Float64(z * Float64(t - a)) / Float64(y + Float64(z * b)));
	else
		tmp = Float64(Float64(t / Float64(b - y)) - Float64(a / Float64(b - y)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -5.346553857333096e-17], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.453155276752717e-161], N[(N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.0606006390105884e-12], N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision] - N[(a / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET tmp_2 = IF (z <= (20606006390105883982817420153520342781909568952158906540716998279094696044921875e-91)) THEN ((z * (t - a)) / (y + (z * b))) ELSE ((t / (b - y)) - (a / (b - y))) ENDIF IN
	LET tmp_1 = IF (z <= (44531552767527170474802959919290092753531545557429460092853638544720950168949417396965382575798778208655977542449222908822916161154447094613044478557065067185496970956429002653206848882621145565112985862710985163615323882102665213042088823384421191840948203551944934514434321374976760094526166480819213789405925800138383204625638235643622938486118737509752723474195219456321201043601243352298979516490362584590911865234375e-582)) THEN (((t * z) + (x * y)) / (y + (z * (b - y)))) ELSE tmp_2 ENDIF IN
	LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN ((t - a) / (b - y)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if z < -5.3465538573330963e-17

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 4.453155276752717e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in a around 0

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

   4. Applied rewrites 46.3%

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

   if 4.453155276752717e-161 < z < 2.0606006390105884e-12

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 56.1%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 34.7%

      \[\leadsto \frac{z \cdot \left(t - a\right)}{y + z \cdot b} \]

   if 2.0606006390105884e-12 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]
   5. Step-by-step derivation

   6. Applied rewrites 51.9%

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

Alternative 5: 74.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;\frac{t - a}{b - y}\\ \mathbf{elif}\;z \leq 1.551764990849057 \cdot 10^{-161}:\\ \;\;\;\;\frac{t\_1}{y} + x\\ \mathbf{elif}\;z \leq 2.0606006390105884 \cdot 10^{-12}:\\ \;\;\;\;\frac{t\_1}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b - y} - \frac{a}{b - y}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* z (- t a))))
  (if (<= z -5.346553857333096e-17)
    (/ (- t a) (- b y))
    (if (<= z 1.551764990849057e-161)
      (+ (/ t_1 y) x)
      (if (<= z 2.0606006390105884e-12)
        (/ t_1 (+ y (* z b)))
        (- (/ t (- b y)) (/ a (- b y))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = (t - a) / (b - y);
	} else if (z <= 1.551764990849057e-161) {
		tmp = (t_1 / y) + x;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = t_1 / (y + (z * b));
	} else {
		tmp = (t / (b - y)) - (a / (b - y));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = z * (t - a)
    if (z <= (-5.346553857333096d-17)) then
        tmp = (t - a) / (b - y)
    else if (z <= 1.551764990849057d-161) then
        tmp = (t_1 / y) + x
    else if (z <= 2.0606006390105884d-12) then
        tmp = t_1 / (y + (z * b))
    else
        tmp = (t / (b - y)) - (a / (b - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = (t - a) / (b - y);
	} else if (z <= 1.551764990849057e-161) {
		tmp = (t_1 / y) + x;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = t_1 / (y + (z * b));
	} else {
		tmp = (t / (b - y)) - (a / (b - y));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	tmp = 0
	if z <= -5.346553857333096e-17:
		tmp = (t - a) / (b - y)
	elif z <= 1.551764990849057e-161:
		tmp = (t_1 / y) + x
	elif z <= 2.0606006390105884e-12:
		tmp = t_1 / (y + (z * b))
	else:
		tmp = (t / (b - y)) - (a / (b - y))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = Float64(Float64(t - a) / Float64(b - y));
	elseif (z <= 1.551764990849057e-161)
		tmp = Float64(Float64(t_1 / y) + x);
	elseif (z <= 2.0606006390105884e-12)
		tmp = Float64(t_1 / Float64(y + Float64(z * b)));
	else
		tmp = Float64(Float64(t / Float64(b - y)) - Float64(a / Float64(b - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	tmp = 0.0;
	if (z <= -5.346553857333096e-17)
		tmp = (t - a) / (b - y);
	elseif (z <= 1.551764990849057e-161)
		tmp = (t_1 / y) + x;
	elseif (z <= 2.0606006390105884e-12)
		tmp = t_1 / (y + (z * b));
	else
		tmp = (t / (b - y)) - (a / (b - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.346553857333096e-17], N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.551764990849057e-161], N[(N[(t$95$1 / y), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 2.0606006390105884e-12], N[(t$95$1 / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t / N[(b - y), $MachinePrecision]), $MachinePrecision] - N[(a / N[(b - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (z * (t - a)) IN
		LET tmp_2 = IF (z <= (20606006390105883982817420153520342781909568952158906540716998279094696044921875e-91)) THEN (t_1 / (y + (z * b))) ELSE ((t / (b - y)) - (a / (b - y))) ENDIF IN
		LET tmp_1 = IF (z <= (15517649908490570518076219234720905517607150981987541499739102892095318766620393099690839930715261546320251742313784857626694099653977249850711037301681994706511213237314105879493021245180614807251975600999426048681105753564521076681127267578491067110895558895697006073018351243492280241475092106724315022299966232614316797628774637893153228943658833664859986990161681168023770699599707401095116665601381100714206695556640625e-585)) THEN ((t_1 / y) + x) ELSE tmp_2 ENDIF IN
		LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN ((t - a) / (b - y)) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if z < -5.3465538573330963e-17

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 1.5517649908490571e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in z around 0

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

   4. Applied rewrites 27.2%

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

   5. Taylor expanded in a around inf

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 32.0%

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 30.4%

      \[\leadsto \left(-z \cdot \frac{a}{y}\right) + x \]

   10. Taylor expanded in x around 0

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

   12. Applied rewrites 37.7%

       \[\leadsto \frac{z \cdot \left(t - a\right)}{y} + x \]

   if 1.5517649908490571e-161 < z < 2.0606006390105884e-12

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 56.1%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 34.7%

      \[\leadsto \frac{z \cdot \left(t - a\right)}{y + z \cdot b} \]

   if 2.0606006390105884e-12 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]
   5. Step-by-step derivation

   6. Applied rewrites 51.9%

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

Alternative 6: 74.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := z \cdot \left(t - a\right)\\ t_2 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;z \leq 1.551764990849057 \cdot 10^{-161}:\\ \;\;\;\;\frac{t\_1}{y} + x\\ \mathbf{elif}\;z \leq 8.772668701169 \cdot 10^{+17}:\\ \;\;\;\;\frac{t\_1}{y + z \cdot b}\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* z (- t a))) (t_2 (/ (- t a) (- b y))))
  (if (<= z -5.346553857333096e-17)
    t_2
    (if (<= z 1.551764990849057e-161)
      (+ (/ t_1 y) x)
      (if (<= z 8.772668701169e+17) (/ t_1 (+ y (* z b))) t_2)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_2;
	} else if (z <= 1.551764990849057e-161) {
		tmp = (t_1 / y) + x;
	} else if (z <= 8.772668701169e+17) {
		tmp = t_1 / (y + (z * b));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = z * (t - a)
    t_2 = (t - a) / (b - y)
    if (z <= (-5.346553857333096d-17)) then
        tmp = t_2
    else if (z <= 1.551764990849057d-161) then
        tmp = (t_1 / y) + x
    else if (z <= 8.772668701169d+17) then
        tmp = t_1 / (y + (z * b))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = z * (t - a);
	double t_2 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_2;
	} else if (z <= 1.551764990849057e-161) {
		tmp = (t_1 / y) + x;
	} else if (z <= 8.772668701169e+17) {
		tmp = t_1 / (y + (z * b));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = z * (t - a)
	t_2 = (t - a) / (b - y)
	tmp = 0
	if z <= -5.346553857333096e-17:
		tmp = t_2
	elif z <= 1.551764990849057e-161:
		tmp = (t_1 / y) + x
	elif z <= 8.772668701169e+17:
		tmp = t_1 / (y + (z * b))
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(z * Float64(t - a))
	t_2 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = t_2;
	elseif (z <= 1.551764990849057e-161)
		tmp = Float64(Float64(t_1 / y) + x);
	elseif (z <= 8.772668701169e+17)
		tmp = Float64(t_1 / Float64(y + Float64(z * b)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = z * (t - a);
	t_2 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -5.346553857333096e-17)
		tmp = t_2;
	elseif (z <= 1.551764990849057e-161)
		tmp = (t_1 / y) + x;
	elseif (z <= 8.772668701169e+17)
		tmp = t_1 / (y + (z * b));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.346553857333096e-17], t$95$2, If[LessEqual[z, 1.551764990849057e-161], N[(N[(t$95$1 / y), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 8.772668701169e+17], N[(t$95$1 / N[(y + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (z * (t - a)) IN
		LET t_2 = ((t - a) / (b - y)) IN
			LET tmp_2 = IF (z <= (877266870116899968)) THEN (t_1 / (y + (z * b))) ELSE t_2 ENDIF IN
			LET tmp_1 = IF (z <= (15517649908490570518076219234720905517607150981987541499739102892095318766620393099690839930715261546320251742313784857626694099653977249850711037301681994706511213237314105879493021245180614807251975600999426048681105753564521076681127267578491067110895558895697006073018351243492280241475092106724315022299966232614316797628774637893153228943658833664859986990161681168023770699599707401095116665601381100714206695556640625e-585)) THEN ((t_1 / y) + x) ELSE tmp_2 ENDIF IN
			LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN t_2 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if z < -5.3465538573330963e-17 or 877266870116899970 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 1.5517649908490571e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in z around 0

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

   4. Applied rewrites 27.2%

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

   5. Taylor expanded in a around inf

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 32.0%

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 30.4%

      \[\leadsto \left(-z \cdot \frac{a}{y}\right) + x \]

   10. Taylor expanded in x around 0

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

   12. Applied rewrites 37.7%

       \[\leadsto \frac{z \cdot \left(t - a\right)}{y} + x \]

   if 1.5517649908490571e-161 < z < 877266870116899970

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 56.1%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 34.7%

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

Alternative 7: 74.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.551764990849057 \cdot 10^{-161}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right)}{y} + x\\ \mathbf{elif}\;z \leq 8.772668701169 \cdot 10^{+17}:\\ \;\;\;\;\frac{\left(t - a\right) \cdot z}{\mathsf{fma}\left(b, z, y\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -5.346553857333096e-17)
    t_1
    (if (<= z 1.551764990849057e-161)
      (+ (/ (* z (- t a)) y) x)
      (if (<= z 8.772668701169e+17)
        (/ (* (- t a) z) (fma b z y))
        t_1)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_1;
	} else if (z <= 1.551764990849057e-161) {
		tmp = ((z * (t - a)) / y) + x;
	} else if (z <= 8.772668701169e+17) {
		tmp = ((t - a) * z) / fma(b, z, y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = t_1;
	elseif (z <= 1.551764990849057e-161)
		tmp = Float64(Float64(Float64(z * Float64(t - a)) / y) + x);
	elseif (z <= 8.772668701169e+17)
		tmp = Float64(Float64(Float64(t - a) * z) / fma(b, z, y));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.346553857333096e-17], t$95$1, If[LessEqual[z, 1.551764990849057e-161], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 8.772668701169e+17], N[(N[(N[(t - a), $MachinePrecision] * z), $MachinePrecision] / N[(b * z + y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / (b - y)) IN
		LET tmp_2 = IF (z <= (877266870116899968)) THEN (((t - a) * z) / ((b * z) + y)) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (z <= (15517649908490570518076219234720905517607150981987541499739102892095318766620393099690839930715261546320251742313784857626694099653977249850711037301681994706511213237314105879493021245180614807251975600999426048681105753564521076681127267578491067110895558895697006073018351243492280241475092106724315022299966232614316797628774637893153228943658833664859986990161681168023770699599707401095116665601381100714206695556640625e-585)) THEN (((z * (t - a)) / y) + x) ELSE tmp_2 ENDIF IN
		LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if z < -5.3465538573330963e-17 or 877266870116899970 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 1.5517649908490571e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in z around 0

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

   4. Applied rewrites 27.2%

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

   5. Taylor expanded in a around inf

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 32.0%

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 30.4%

      \[\leadsto \left(-z \cdot \frac{a}{y}\right) + x \]

   10. Taylor expanded in x around 0

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

   12. Applied rewrites 37.7%

       \[\leadsto \frac{z \cdot \left(t - a\right)}{y} + x \]

   if 1.5517649908490571e-161 < z < 877266870116899970

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 56.1%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 34.7%

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

   9. Applied rewrites 34.7%

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

Alternative 8: 71.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.0606006390105884 \cdot 10^{-12}:\\ \;\;\;\;\frac{z \cdot \left(t - a\right)}{y} + x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -5.346553857333096e-17)
    t_1
    (if (<= z 2.0606006390105884e-12) (+ (/ (* z (- t a)) y) x) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_1;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = ((z * (t - a)) / y) + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-5.346553857333096d-17)) then
        tmp = t_1
    else if (z <= 2.0606006390105884d-12) then
        tmp = ((z * (t - a)) / y) + x
    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 t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_1;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = ((z * (t - a)) / y) + x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -5.346553857333096e-17:
		tmp = t_1
	elif z <= 2.0606006390105884e-12:
		tmp = ((z * (t - a)) / y) + x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = t_1;
	elseif (z <= 2.0606006390105884e-12)
		tmp = Float64(Float64(Float64(z * Float64(t - a)) / y) + x);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -5.346553857333096e-17)
		tmp = t_1;
	elseif (z <= 2.0606006390105884e-12)
		tmp = ((z * (t - a)) / y) + x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.346553857333096e-17], t$95$1, If[LessEqual[z, 2.0606006390105884e-12], N[(N[(N[(z * N[(t - a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / (b - y)) IN
		LET tmp_1 = IF (z <= (20606006390105883982817420153520342781909568952158906540716998279094696044921875e-91)) THEN (((z * (t - a)) / y) + x) ELSE t_1 ENDIF IN
		LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -5.3465538573330963e-17 or 2.0606006390105884e-12 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 2.0606006390105884e-12

   1. Initial program 65.9%

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

   2. Taylor expanded in z around 0

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

   4. Applied rewrites 27.2%

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

   5. Taylor expanded in a around inf

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 32.0%

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 30.4%

      \[\leadsto \left(-z \cdot \frac{a}{y}\right) + x \]

   10. Taylor expanded in x around 0

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

   12. Applied rewrites 37.7%

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

Alternative 9: 69.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -5.346553857333096 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 2.0606006390105884 \cdot 10^{-12}:\\ \;\;\;\;x + \frac{a \cdot z}{-y}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -5.346553857333096e-17)
    t_1
    (if (<= z 2.0606006390105884e-12) (+ x (/ (* a z) (- y))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_1;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = x + ((a * z) / -y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-5.346553857333096d-17)) then
        tmp = t_1
    else if (z <= 2.0606006390105884d-12) then
        tmp = x + ((a * z) / -y)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -5.346553857333096e-17) {
		tmp = t_1;
	} else if (z <= 2.0606006390105884e-12) {
		tmp = x + ((a * z) / -y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -5.346553857333096e-17:
		tmp = t_1
	elif z <= 2.0606006390105884e-12:
		tmp = x + ((a * z) / -y)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -5.346553857333096e-17)
		tmp = t_1;
	elseif (z <= 2.0606006390105884e-12)
		tmp = Float64(x + Float64(Float64(a * z) / Float64(-y)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -5.346553857333096e-17)
		tmp = t_1;
	elseif (z <= 2.0606006390105884e-12)
		tmp = x + ((a * z) / -y);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.346553857333096e-17], t$95$1, If[LessEqual[z, 2.0606006390105884e-12], N[(x + N[(N[(a * z), $MachinePrecision] / (-y)), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / (b - y)) IN
		LET tmp_1 = IF (z <= (20606006390105883982817420153520342781909568952158906540716998279094696044921875e-91)) THEN (x + ((a * z) / (- y))) ELSE t_1 ENDIF IN
		LET tmp = IF (z <= (-534655385733309628108169359888334491548161428865586219938421663755434565246105194091796875e-106)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -5.3465538573330963e-17 or 2.0606006390105884e-12 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -5.3465538573330963e-17 < z < 2.0606006390105884e-12

   1. Initial program 65.9%

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

   2. Taylor expanded in z around 0

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

   4. Applied rewrites 27.2%

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

   5. Taylor expanded in a around inf

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   6. Step-by-step derivation

   7. Applied rewrites 32.0%

      \[\leadsto x + -1 \cdot \frac{a \cdot z}{y} \]
   8. Step-by-step derivation

   9. Applied rewrites 32.0%

      \[\leadsto x + \frac{a \cdot z}{-y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 61.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b - y}\\ \mathbf{if}\;z \leq -9.066726755878833 \cdot 10^{-152}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 7.733378967822915 \cdot 10^{-206}:\\ \;\;\;\;x \cdot 1\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) (- b y))))
  (if (<= z -9.066726755878833e-152)
    t_1
    (if (<= z 7.733378967822915e-206) (* x 1.0) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -9.066726755878833e-152) {
		tmp = t_1;
	} else if (z <= 7.733378967822915e-206) {
		tmp = x * 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / (b - y)
    if (z <= (-9.066726755878833d-152)) then
        tmp = t_1
    else if (z <= 7.733378967822915d-206) then
        tmp = x * 1.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 t_1 = (t - a) / (b - y);
	double tmp;
	if (z <= -9.066726755878833e-152) {
		tmp = t_1;
	} else if (z <= 7.733378967822915e-206) {
		tmp = x * 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / (b - y)
	tmp = 0
	if z <= -9.066726755878833e-152:
		tmp = t_1
	elif z <= 7.733378967822915e-206:
		tmp = x * 1.0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / Float64(b - y))
	tmp = 0.0
	if (z <= -9.066726755878833e-152)
		tmp = t_1;
	elseif (z <= 7.733378967822915e-206)
		tmp = Float64(x * 1.0);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / (b - y);
	tmp = 0.0;
	if (z <= -9.066726755878833e-152)
		tmp = t_1;
	elseif (z <= 7.733378967822915e-206)
		tmp = x * 1.0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / N[(b - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -9.066726755878833e-152], t$95$1, If[LessEqual[z, 7.733378967822915e-206], N[(x * 1.0), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / (b - y)) IN
		LET tmp_1 = IF (z <= (7733378967822915087535687083457690143841288065603029792793743531878409430070102727679240347487936266205702954600764830955765680930127760082032623914364932764348975455014677621922934568187648451451870570070129532337206107266070907476787796760418779935110938477562755976094235138420537343238640398829585000562245616333784933428647551439104301170850865855067143820824126957771887608707769012674032173526821245304163877669948408410298295152036232940412586844401287276515062200658413001658621037381902141305545228533446788787841796875e-734)) THEN (x * (1)) ELSE t_1 ENDIF IN
		LET tmp = IF (z <= (-90667267558788332653972974449815272840966442157317814308083398856227132431409870747309483789779596717773609003568482527685879080320425182868097295205993728618461526934767719554583334914955467467269256711715426168793141655181172450781115474067682380779024420823960651613052497377491614393838078879252611024186388412130529379807226462133586608816271323958005715591690343302389010204933583736419677734375e-552)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -9.0667267558788333e-152 or 7.7333789678229151e-206 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   if -9.0667267558788333e-152 < z < 7.7333789678229151e-206

   1. Initial program 65.9%

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

   2. Taylor expanded in x around inf

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

   4. Applied rewrites 27.9%

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

   6. Applied rewrites 35.3%

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

   7. Taylor expanded in z around 0

      \[\leadsto x \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 24.7%

      \[\leadsto x \cdot 1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 53.8% accurate, 1.1× speedup

Math

\[\begin{array}{l} t_1 := \frac{x}{1 - z}\\ t_2 := \frac{t - a}{b}\\ \mathbf{if}\;b \leq -6.160672423561748 \cdot 10^{+91}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;b \leq -1.8467040474317478 \cdot 10^{-199}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;b \leq 2.5142714924817374 \cdot 10^{-161}:\\ \;\;\;\;\frac{t - a}{-y}\\ \mathbf{elif}\;b \leq 1.3520027799402172 \cdot 10^{+20}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ x (- 1.0 z))) (t_2 (/ (- t a) b)))
  (if (<= b -6.160672423561748e+91)
    t_2
    (if (<= b -1.8467040474317478e-199)
      t_1
      (if (<= b 2.5142714924817374e-161)
        (/ (- t a) (- y))
        (if (<= b 1.3520027799402172e+20) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double t_2 = (t - a) / b;
	double tmp;
	if (b <= -6.160672423561748e+91) {
		tmp = t_2;
	} else if (b <= -1.8467040474317478e-199) {
		tmp = t_1;
	} else if (b <= 2.5142714924817374e-161) {
		tmp = (t - a) / -y;
	} else if (b <= 1.3520027799402172e+20) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x / (1.0d0 - z)
    t_2 = (t - a) / b
    if (b <= (-6.160672423561748d+91)) then
        tmp = t_2
    else if (b <= (-1.8467040474317478d-199)) then
        tmp = t_1
    else if (b <= 2.5142714924817374d-161) then
        tmp = (t - a) / -y
    else if (b <= 1.3520027799402172d+20) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double t_2 = (t - a) / b;
	double tmp;
	if (b <= -6.160672423561748e+91) {
		tmp = t_2;
	} else if (b <= -1.8467040474317478e-199) {
		tmp = t_1;
	} else if (b <= 2.5142714924817374e-161) {
		tmp = (t - a) / -y;
	} else if (b <= 1.3520027799402172e+20) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (1.0 - z)
	t_2 = (t - a) / b
	tmp = 0
	if b <= -6.160672423561748e+91:
		tmp = t_2
	elif b <= -1.8467040474317478e-199:
		tmp = t_1
	elif b <= 2.5142714924817374e-161:
		tmp = (t - a) / -y
	elif b <= 1.3520027799402172e+20:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(1.0 - z))
	t_2 = Float64(Float64(t - a) / b)
	tmp = 0.0
	if (b <= -6.160672423561748e+91)
		tmp = t_2;
	elseif (b <= -1.8467040474317478e-199)
		tmp = t_1;
	elseif (b <= 2.5142714924817374e-161)
		tmp = Float64(Float64(t - a) / Float64(-y));
	elseif (b <= 1.3520027799402172e+20)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (1.0 - z);
	t_2 = (t - a) / b;
	tmp = 0.0;
	if (b <= -6.160672423561748e+91)
		tmp = t_2;
	elseif (b <= -1.8467040474317478e-199)
		tmp = t_1;
	elseif (b <= 2.5142714924817374e-161)
		tmp = (t - a) / -y;
	elseif (b <= 1.3520027799402172e+20)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[b, -6.160672423561748e+91], t$95$2, If[LessEqual[b, -1.8467040474317478e-199], t$95$1, If[LessEqual[b, 2.5142714924817374e-161], N[(N[(t - a), $MachinePrecision] / (-y)), $MachinePrecision], If[LessEqual[b, 1.3520027799402172e+20], t$95$1, t$95$2]]]]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (x / ((1) - z)) IN
		LET t_2 = ((t - a) / b) IN
			LET tmp_3 = IF (b <= (135200277994021715968)) THEN t_1 ELSE t_2 ENDIF IN
			LET tmp_2 = IF (b <= (251427149248173741810988836536832394511023351445143796753769518572900689551807393329638568656644928624512456320588738264802579671503369838018220684163194457598925327858102359749628893882607442756426648758430656027980808718674940802062152844406456136533423928267064875982863719588686279365142085758798203597833968383170332519056974012976790732484093464681907088758695447116005313565288703525624214307754300534725189208984375e-583)) THEN ((t - a) / (- y)) ELSE tmp_3 ENDIF IN
			LET tmp_1 = IF (b <= (-1846704047431747841977946474476465278441200321888421472364139373550598924385301948666114883064405065322591158596342609543947661099996989818567029491275378013170421698347121268130765077778366372578868487094071063467745981420994240134074772105332834915452058914468952531943224576398408551504717415691410998397887263306022286623728793728358490392250712659697866534868137101551044275208461753001875443366909305263788224403936480306685352464077374870504248272257979332955203448894676565572581239393912255764007568359375e-712)) THEN t_1 ELSE tmp_2 ENDIF IN
			LET tmp = IF (b <= (-61606724235617478173257680582754635485569162628805454294996352748662705123640123507523715072)) THEN t_2 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if b < -6.1606724235617478e91 or 135200277994021720000 < b

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 35.2%

      \[\leadsto \frac{t - a}{b} \]

   if -6.1606724235617478e91 < b < -1.8467040474317478e-199 or 2.5142714924817374e-161 < b < 135200277994021720000

   1. Initial program 65.9%

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

   2. Taylor expanded in y around -inf

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

   4. Applied rewrites 32.2%

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

   6. Applied rewrites 32.2%

      \[\leadsto \frac{x}{1 - z} \]

   if -1.8467040474317478e-199 < b < 2.5142714924817374e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in z around inf

      \[\leadsto \frac{t - a}{b - y} \]
   3. Step-by-step derivation

   4. Applied rewrites 52.3%

      \[\leadsto \frac{t - a}{b - y} \]

   5. Taylor expanded in y around inf

      \[\leadsto \frac{t - a}{-1 \cdot y} \]
   6. Step-by-step derivation

   7. Applied rewrites 22.2%

      \[\leadsto \frac{t - a}{-1 \cdot y} \]
   8. Step-by-step derivation

   9. Applied rewrites 22.2%

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

Alternative 12: 44.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} t_1 := \frac{x}{1 - z}\\ \mathbf{if}\;y \leq -14.795356577707446:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 116591198181.10788:\\ \;\;\;\;\frac{t - a}{b}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ x (- 1.0 z))))
  (if (<= y -14.795356577707446)
    t_1
    (if (<= y 116591198181.10788) (/ (- t a) b) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -14.795356577707446) {
		tmp = t_1;
	} else if (y <= 116591198181.10788) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = x / (1.0d0 - z)
    if (y <= (-14.795356577707446d0)) then
        tmp = t_1
    else if (y <= 116591198181.10788d0) then
        tmp = (t - a) / b
    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 t_1 = x / (1.0 - z);
	double tmp;
	if (y <= -14.795356577707446) {
		tmp = t_1;
	} else if (y <= 116591198181.10788) {
		tmp = (t - a) / b;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x / (1.0 - z)
	tmp = 0
	if y <= -14.795356577707446:
		tmp = t_1
	elif y <= 116591198181.10788:
		tmp = (t - a) / b
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x / Float64(1.0 - z))
	tmp = 0.0
	if (y <= -14.795356577707446)
		tmp = t_1;
	elseif (y <= 116591198181.10788)
		tmp = Float64(Float64(t - a) / b);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x / (1.0 - z);
	tmp = 0.0;
	if (y <= -14.795356577707446)
		tmp = t_1;
	elseif (y <= 116591198181.10788)
		tmp = (t - a) / b;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -14.795356577707446], t$95$1, If[LessEqual[y, 116591198181.10788], N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = (x / ((1) - z)) IN
		LET tmp_1 = IF (y <= (116591198181107879638671875e-15)) THEN ((t - a) / b) ELSE t_1 ENDIF IN
		LET tmp = IF (y <= (-147953565777074462772588958614505827426910400390625e-49)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if y < -14.795356577707446 or 116591198181.10788 < y

   1. Initial program 65.9%

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

   2. Taylor expanded in y around -inf

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

   4. Applied rewrites 32.2%

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

   6. Applied rewrites 32.2%

      \[\leadsto \frac{x}{1 - z} \]

   if -14.795356577707446 < y < 116591198181.10788

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 35.2%

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

Alternative 13: 44.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - a}{b}\\ \mathbf{if}\;z \leq -2.7219516585968082 \cdot 10^{-151}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 7.733378967822915 \cdot 10^{-206}:\\ \;\;\;\;x \cdot 1\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (- t a) b)))
  (if (<= z -2.7219516585968082e-151)
    t_1
    (if (<= z 7.733378967822915e-206) (* x 1.0) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (t - a) / b;
	double tmp;
	if (z <= -2.7219516585968082e-151) {
		tmp = t_1;
	} else if (z <= 7.733378967822915e-206) {
		tmp = x * 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: t_1
    real(8) :: tmp
    t_1 = (t - a) / b
    if (z <= (-2.7219516585968082d-151)) then
        tmp = t_1
    else if (z <= 7.733378967822915d-206) then
        tmp = x * 1.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 t_1 = (t - a) / b;
	double tmp;
	if (z <= -2.7219516585968082e-151) {
		tmp = t_1;
	} else if (z <= 7.733378967822915e-206) {
		tmp = x * 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (t - a) / b
	tmp = 0
	if z <= -2.7219516585968082e-151:
		tmp = t_1
	elif z <= 7.733378967822915e-206:
		tmp = x * 1.0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(t - a) / b)
	tmp = 0.0
	if (z <= -2.7219516585968082e-151)
		tmp = t_1;
	elseif (z <= 7.733378967822915e-206)
		tmp = Float64(x * 1.0);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (t - a) / b;
	tmp = 0.0;
	if (z <= -2.7219516585968082e-151)
		tmp = t_1;
	elseif (z <= 7.733378967822915e-206)
		tmp = x * 1.0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t - a), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[z, -2.7219516585968082e-151], t$95$1, If[LessEqual[z, 7.733378967822915e-206], N[(x * 1.0), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET t_1 = ((t - a) / b) IN
		LET tmp_1 = IF (z <= (7733378967822915087535687083457690143841288065603029792793743531878409430070102727679240347487936266205702954600764830955765680930127760082032623914364932764348975455014677621922934568187648451451870570070129532337206107266070907476787796760418779935110938477562755976094235138420537343238640398829585000562245616333784933428647551439104301170850865855067143820824126957771887608707769012674032173526821245304163877669948408410298295152036232940412586844401287276515062200658413001658621037381902141305545228533446788787841796875e-734)) THEN (x * (1)) ELSE t_1 ENDIF IN
		LET tmp = IF (z <= (-2721951658596808200139153233924810779507148519153781458729363046295206517821052340450796540155122184902306671959196295849322414393436469081324884567385986556411513918499038093522345736671287276586426286706077740102719807531337685156715596472789900169111894994078665884840026146125725563217271503728846999011206680263836266729093468262998761177997512525665322669944645728179466459550894796848297119140625e-553)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -2.7219516585968082e-151 or 7.7333789678229151e-206 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 35.2%

      \[\leadsto \frac{t - a}{b} \]

   if -2.7219516585968082e-151 < z < 7.7333789678229151e-206

   1. Initial program 65.9%

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

   2. Taylor expanded in x around inf

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

   4. Applied rewrites 27.9%

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

   6. Applied rewrites 35.3%

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

   7. Taylor expanded in z around 0

      \[\leadsto x \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 24.7%

      \[\leadsto x \cdot 1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 36.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;z \leq -2.4484361954693226 \cdot 10^{-14}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq 5.473902574221048 \cdot 10^{-161}:\\ \;\;\;\;x \cdot 1\\ \mathbf{else}:\\ \;\;\;\;\frac{-a}{b}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (if (<= z -2.4484361954693226e-14)
  (/ t b)
  (if (<= z 5.473902574221048e-161) (* x 1.0) (/ (- a) b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -2.4484361954693226e-14) {
		tmp = t / b;
	} else if (z <= 5.473902574221048e-161) {
		tmp = x * 1.0;
	} else {
		tmp = -a / b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: tmp
    if (z <= (-2.4484361954693226d-14)) then
        tmp = t / b
    else if (z <= 5.473902574221048d-161) then
        tmp = x * 1.0d0
    else
        tmp = -a / b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -2.4484361954693226e-14) {
		tmp = t / b;
	} else if (z <= 5.473902574221048e-161) {
		tmp = x * 1.0;
	} else {
		tmp = -a / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -2.4484361954693226e-14:
		tmp = t / b
	elif z <= 5.473902574221048e-161:
		tmp = x * 1.0
	else:
		tmp = -a / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -2.4484361954693226e-14)
		tmp = Float64(t / b);
	elseif (z <= 5.473902574221048e-161)
		tmp = Float64(x * 1.0);
	else
		tmp = Float64(Float64(-a) / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -2.4484361954693226e-14)
		tmp = t / b;
	elseif (z <= 5.473902574221048e-161)
		tmp = x * 1.0;
	else
		tmp = -a / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -2.4484361954693226e-14], N[(t / b), $MachinePrecision], If[LessEqual[z, 5.473902574221048e-161], N[(x * 1.0), $MachinePrecision], N[((-a) / b), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET tmp_1 = IF (z <= (54739025742210478264985542537343754568975602540261654904490375096497878943351304352022167780790231566814085062806731556231105876630427443455701379512389657791464694753491776499726262677810561829743054820878941611132338604600704245320449088862427015851646023898494406324951162661707913126656677232148428925649058818964208404239026294182621539208983806300198770567855597029162495240051621026022843352620839141309261322021484375e-585)) THEN (x * (1)) ELSE ((- a) / b) ENDIF IN
	LET tmp = IF (z <= (-2448436195469322597650465738125504909860979084468279864950090995989739894866943359375e-98)) THEN (t / b) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if z < -2.4484361954693226e-14

   1. Initial program 65.9%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 23.1%

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

   6. Applied rewrites 26.0%

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

   7. Taylor expanded in z around inf

      \[\leadsto \frac{t}{b - y} \]
   8. Step-by-step derivation

   9. Applied rewrites 28.3%

      \[\leadsto \frac{t}{b - y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{t}{b} \]
   11. Step-by-step derivation

   12. Applied rewrites 19.9%

       \[\leadsto \frac{t}{b} \]

   if -2.4484361954693226e-14 < z < 5.4739025742210478e-161

   1. Initial program 65.9%

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

   2. Taylor expanded in x around inf

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

   4. Applied rewrites 27.9%

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

   6. Applied rewrites 35.3%

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

   7. Taylor expanded in z around 0

      \[\leadsto x \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 24.7%

      \[\leadsto x \cdot 1 \]

   if 5.4739025742210478e-161 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in y around 0

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

   4. Applied rewrites 35.2%

      \[\leadsto \frac{t - a}{b} \]

   5. Taylor expanded in t around 0

      \[\leadsto \frac{-1 \cdot a}{b} \]
   6. Step-by-step derivation

   7. Applied rewrites 20.6%

      \[\leadsto \frac{-1 \cdot a}{b} \]
   8. Step-by-step derivation

   9. Applied rewrites 20.6%

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

Alternative 15: 34.1% accurate, 2.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;z \leq -2.4484361954693226 \cdot 10^{-14}:\\ \;\;\;\;\frac{t}{b}\\ \mathbf{elif}\;z \leq 2.2882723272429134 \cdot 10^{-11}:\\ \;\;\;\;x \cdot 1\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{b}\\ \end{array} \]

FPCore

(FPCore (x y z t a b)
  :precision binary64
  :pre TRUE
  (if (<= z -2.4484361954693226e-14)
  (/ t b)
  (if (<= z 2.2882723272429134e-11) (* x 1.0) (/ t b))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -2.4484361954693226e-14) {
		tmp = t / b;
	} else if (z <= 2.2882723272429134e-11) {
		tmp = x * 1.0;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
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) :: tmp
    if (z <= (-2.4484361954693226d-14)) then
        tmp = t / b
    else if (z <= 2.2882723272429134d-11) then
        tmp = x * 1.0d0
    else
        tmp = t / b
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (z <= -2.4484361954693226e-14) {
		tmp = t / b;
	} else if (z <= 2.2882723272429134e-11) {
		tmp = x * 1.0;
	} else {
		tmp = t / b;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if z <= -2.4484361954693226e-14:
		tmp = t / b
	elif z <= 2.2882723272429134e-11:
		tmp = x * 1.0
	else:
		tmp = t / b
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (z <= -2.4484361954693226e-14)
		tmp = Float64(t / b);
	elseif (z <= 2.2882723272429134e-11)
		tmp = Float64(x * 1.0);
	else
		tmp = Float64(t / b);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (z <= -2.4484361954693226e-14)
		tmp = t / b;
	elseif (z <= 2.2882723272429134e-11)
		tmp = x * 1.0;
	else
		tmp = t / b;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -2.4484361954693226e-14], N[(t / b), $MachinePrecision], If[LessEqual[z, 2.2882723272429134e-11], N[(x * 1.0), $MachinePrecision], N[(t / b), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a, b):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf],
	b in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a, b: real): real =
	LET tmp_1 = IF (z <= (2288272327242913430161182968417877582611996700734380283392965793609619140625e-86)) THEN (x * (1)) ELSE (t / b) ENDIF IN
	LET tmp = IF (z <= (-2448436195469322597650465738125504909860979084468279864950090995989739894866943359375e-98)) THEN (t / b) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if z < -2.4484361954693226e-14 or 2.2882723272429134e-11 < z

   1. Initial program 65.9%

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

   2. Taylor expanded in t around inf

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

   4. Applied rewrites 23.1%

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

   6. Applied rewrites 26.0%

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

   7. Taylor expanded in z around inf

      \[\leadsto \frac{t}{b - y} \]
   8. Step-by-step derivation

   9. Applied rewrites 28.3%

      \[\leadsto \frac{t}{b - y} \]

   10. Taylor expanded in y around 0

       \[\leadsto \frac{t}{b} \]
   11. Step-by-step derivation

   12. Applied rewrites 19.9%

       \[\leadsto \frac{t}{b} \]

   if -2.4484361954693226e-14 < z < 2.2882723272429134e-11

   1. Initial program 65.9%

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

   2. Taylor expanded in x around inf

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

   4. Applied rewrites 27.9%

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

   6. Applied rewrites 35.3%

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

   7. Taylor expanded in z around 0

      \[\leadsto x \cdot 1 \]
   8. Step-by-step derivation

   9. Applied rewrites 24.7%

      \[\leadsto x \cdot 1 \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 16: 24.7% accurate, 6.0× speedup

Math

\[x \cdot 1 \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(x * 1.0), $MachinePrecision]

ReFlow

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

Derivation

1. Initial program 65.9%

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

2. Taylor expanded in x around inf

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

4. Applied rewrites 27.9%

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

6. Applied rewrites 35.3%

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

7. Taylor expanded in z around 0

   \[\leadsto x \cdot 1 \]
8. Step-by-step derivation

9. Applied rewrites 24.7%

   \[\leadsto x \cdot 1 \]
10. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t a b)
  :name "Development.Shake.Progress:decay from shake-0.15.5"
  :precision binary64
  (/ (+ (* x y) (* z (- t a))) (+ y (* z (- b y)))))