Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3

Percentage Accurate: 68.2% → 92.6%

Time: 6.7s

Alternatives: 25

Speedup: 0.9×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

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

Initial Program: 68.2% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

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

Alternative 1: 92.6% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1
        (fma
         (- y x)
         (/ z (- a t))
         (- (* (/ t (- t a)) (- y x)) (- x))))
       (t_2 (+ x (/ (* (- y x) (- z t)) (- a t)))))
  (if (<= t_2 -2e-256)
    t_1
    (if (<= t_2 0.0) (+ y (/ (* x (- z a)) t)) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma((y - x), (z / (a - t)), (((t / (t - a)) * (y - x)) - -x));
	double t_2 = x + (((y - x) * (z - t)) / (a - t));
	double tmp;
	if (t_2 <= -2e-256) {
		tmp = t_1;
	} else if (t_2 <= 0.0) {
		tmp = y + ((x * (z - a)) / t);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

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

Wolfram

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

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -2e-256 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t)))

   1. Initial program 68.2%

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

   3. Applied rewrites 88.1%

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

   if -2e-256 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   5. Taylor expanded in x around -inf

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

   7. Applied rewrites 41.4%

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

Alternative 2: 90.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := y - \frac{\left(y - x\right) \cdot 1}{\frac{t}{z - a}}\\ \mathbf{if}\;t \leq -5.006566748163713 \cdot 10^{+122}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 1.1436358581829497 \cdot 10^{+135}:\\ \;\;\;\;x + \left(t - z\right) \cdot \frac{x - y}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (- y (/ (* (- y x) 1.0) (/ t (- z a))))))
  (if (<= t -5.006566748163713e+122)
    t_1
    (if (<= t 1.1436358581829497e+135)
      (+ x (* (- t z) (/ (- x y) (- a t))))
      t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y - (((y - x) * 1.0) / (t / (z - a)));
	double tmp;
	if (t <= -5.006566748163713e+122) {
		tmp = t_1;
	} else if (t <= 1.1436358581829497e+135) {
		tmp = x + ((t - z) * ((x - y) / (a - t)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: t_1
    real(8) :: tmp
    t_1 = y - (((y - x) * 1.0d0) / (t / (z - a)))
    if (t <= (-5.006566748163713d+122)) then
        tmp = t_1
    else if (t <= 1.1436358581829497d+135) then
        tmp = x + ((t - z) * ((x - y) / (a - t)))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y - (((y - x) * 1.0) / (t / (z - a)));
	double tmp;
	if (t <= -5.006566748163713e+122) {
		tmp = t_1;
	} else if (t <= 1.1436358581829497e+135) {
		tmp = x + ((t - z) * ((x - y) / (a - t)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y - (((y - x) * 1.0) / (t / (z - a)))
	tmp = 0
	if t <= -5.006566748163713e+122:
		tmp = t_1
	elif t <= 1.1436358581829497e+135:
		tmp = x + ((t - z) * ((x - y) / (a - t)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y - Float64(Float64(Float64(y - x) * 1.0) / Float64(t / Float64(z - a))))
	tmp = 0.0
	if (t <= -5.006566748163713e+122)
		tmp = t_1;
	elseif (t <= 1.1436358581829497e+135)
		tmp = Float64(x + Float64(Float64(t - z) * Float64(Float64(x - y) / Float64(a - t))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y - (((y - x) * 1.0) / (t / (z - a)));
	tmp = 0.0;
	if (t <= -5.006566748163713e+122)
		tmp = t_1;
	elseif (t <= 1.1436358581829497e+135)
		tmp = x + ((t - z) * ((x - y) / (a - t)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y - N[(N[(N[(y - x), $MachinePrecision] * 1.0), $MachinePrecision] / N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5.006566748163713e+122], t$95$1, If[LessEqual[t, 1.1436358581829497e+135], N[(x + N[(N[(t - z), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if t < -5.006566748163713e122 or 1.1436358581829497e135 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   6. Applied rewrites 51.7%

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

      1. pow1 N/A

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

      2. metadata-eval N/A

         \[\leadsto y - \frac{y - x}{t} \cdot \frac{1}{{\left({\left(z - a\right)}^{\left(\mathsf{neg}\left(-1\right)\right)}\right)}^{-1}} \]

      3. pow-neg N/A

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

      4. remove-sound-/ N/A

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

      5. lower-/.f64 N/A

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

      6. remove-sound-pow N/A

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

      7. lower-pow.f64 51.7%

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

   8. Applied rewrites 51.7%

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

   10. Applied rewrites 53.2%

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

   if -5.006566748163713e122 < t < 1.1436358581829497e135

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

Alternative 3: 87.5% accurate, 0.3× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma (- x y) (/ (- t z) (- a t)) x))
       (t_2 (+ x (/ (* (- y x) (- z t)) (- a t)))))
  (if (<= t_2 -2e-256)
    t_1
    (if (<= t_2 0.0) (+ y (/ (* x (- z a)) t)) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma((x - y), ((t - z) / (a - t)), x);
	double t_2 = x + (((y - x) * (z - t)) / (a - t));
	double tmp;
	if (t_2 <= -2e-256) {
		tmp = t_1;
	} else if (t_2 <= 0.0) {
		tmp = y + ((x * (z - a)) / t);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

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

Wolfram

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

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < -2e-256 or 0.0 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t)))

   1. Initial program 68.2%

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

   3. Applied rewrites 84.2%

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

   if -2e-256 < (+.f64 x (/.f64 (*.f64 (-.f64 y x) (-.f64 z t)) (-.f64 a t))) < 0.0

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   5. Taylor expanded in x around -inf

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

   7. Applied rewrites 41.4%

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

Alternative 4: 87.2% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -5.006566748163713 \cdot 10^{+122}:\\ \;\;\;\;y + \frac{z - a}{\frac{t}{x - y}}\\ \mathbf{elif}\;t \leq 9.559217754916176 \cdot 10^{+142}:\\ \;\;\;\;\mathsf{fma}\left(t - z, \frac{x - y}{a - t}, x\right)\\ \mathbf{else}:\\ \;\;\;\;y - \frac{y - x}{t} \cdot \left(z - a\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -5.006566748163713e+122)
  (+ y (/ (- z a) (/ t (- x y))))
  (if (<= t 9.559217754916176e+142)
    (fma (- t z) (/ (- x y) (- a t)) x)
    (- y (* (/ (- y x) t) (- z a))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -5.006566748163713e+122) {
		tmp = y + ((z - a) / (t / (x - y)));
	} else if (t <= 9.559217754916176e+142) {
		tmp = fma((t - z), ((x - y) / (a - t)), x);
	} else {
		tmp = y - (((y - x) / t) * (z - a));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -5.006566748163713e+122)
		tmp = Float64(y + Float64(Float64(z - a) / Float64(t / Float64(x - y))));
	elseif (t <= 9.559217754916176e+142)
		tmp = fma(Float64(t - z), Float64(Float64(x - y) / Float64(a - t)), x);
	else
		tmp = Float64(y - Float64(Float64(Float64(y - x) / t) * Float64(z - a)));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -5.006566748163713e+122], N[(y + N[(N[(z - a), $MachinePrecision] / N[(t / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.559217754916176e+142], N[(N[(t - z), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(y - N[(N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision] * N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

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

Derivation

1. Split input into 3 regimes

2. if t < -5.006566748163713e122

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   6. Applied rewrites 46.8%

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

   8. Applied rewrites 51.8%

      \[\leadsto y + \frac{z - a}{\frac{t}{x - y}} \]

   if -5.006566748163713e122 < t < 9.5592177549161761e142

   1. Initial program 68.2%

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

   3. Applied rewrites 80.2%

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

   if 9.5592177549161761e142 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   6. Applied rewrites 51.7%

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

Alternative 5: 74.4% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma (- z t) (/ (- y x) a) x)))
  (if (<= a -2.5823261747651478e-30)
    t_1
    (if (<= a 3.2166301160864204e-23)
      (+ y (/ (- z a) (/ t (- x y))))
      t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma((z - t), ((y - x) / a), x);
	double tmp;
	if (a <= -2.5823261747651478e-30) {
		tmp = t_1;
	} else if (a <= 3.2166301160864204e-23) {
		tmp = y + ((z - a) / (t / (x - y)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = fma(Float64(z - t), Float64(Float64(y - x) / a), x)
	tmp = 0.0
	if (a <= -2.5823261747651478e-30)
		tmp = t_1;
	elseif (a <= 3.2166301160864204e-23)
		tmp = Float64(y + Float64(Float64(z - a) / Float64(t / Float64(x - y))));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -2.5823261747651478e-30], t$95$1, If[LessEqual[a, 3.2166301160864204e-23], N[(y + N[(N[(z - a), $MachinePrecision] / N[(t / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if a < -2.5823261747651478e-30 or 3.2166301160864204e-23 < a

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   6. Applied rewrites 52.2%

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

   if -2.5823261747651478e-30 < a < 3.2166301160864204e-23

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   6. Applied rewrites 46.8%

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

   8. Applied rewrites 51.8%

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

Alternative 6: 74.3% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma (- z t) (/ (- y x) a) x)))
  (if (<= a -2.5823261747651478e-30)
    t_1
    (if (<= a 3.2166301160864204e-23)
      (- y (* (/ (- y x) t) (- z a)))
      t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma((z - t), ((y - x) / a), x);
	double tmp;
	if (a <= -2.5823261747651478e-30) {
		tmp = t_1;
	} else if (a <= 3.2166301160864204e-23) {
		tmp = y - (((y - x) / t) * (z - a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = fma(Float64(z - t), Float64(Float64(y - x) / a), x)
	tmp = 0.0
	if (a <= -2.5823261747651478e-30)
		tmp = t_1;
	elseif (a <= 3.2166301160864204e-23)
		tmp = Float64(y - Float64(Float64(Float64(y - x) / t) * Float64(z - a)));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -2.5823261747651478e-30], t$95$1, If[LessEqual[a, 3.2166301160864204e-23], N[(y - N[(N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision] * N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if a < -2.5823261747651478e-30 or 3.2166301160864204e-23 < a

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   6. Applied rewrites 52.2%

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

   if -2.5823261747651478e-30 < a < 3.2166301160864204e-23

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   6. Applied rewrites 51.7%

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

Alternative 7: 72.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} t_1 := \frac{a - z}{a - t} \cdot x\\ \mathbf{if}\;x \leq -1.2899225121418025 \cdot 10^{+120}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -2.866709023809288 \cdot 10^{-75}:\\ \;\;\;\;\mathsf{fma}\left(t, \frac{x - y}{a - t}, x\right)\\ \mathbf{elif}\;x \leq 1.0663586952609725 \cdot 10^{+68}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ (- a z) (- a t)) x)))
  (if (<= x -1.2899225121418025e+120)
    t_1
    (if (<= x -2.866709023809288e-75)
      (fma t (/ (- x y) (- a t)) x)
      (if (<= x 1.0663586952609725e+68)
        (* y (/ (- z t) (- a t)))
        t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = ((a - z) / (a - t)) * x;
	double tmp;
	if (x <= -1.2899225121418025e+120) {
		tmp = t_1;
	} else if (x <= -2.866709023809288e-75) {
		tmp = fma(t, ((x - y) / (a - t)), x);
	} else if (x <= 1.0663586952609725e+68) {
		tmp = y * ((z - t) / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(Float64(a - z) / Float64(a - t)) * x)
	tmp = 0.0
	if (x <= -1.2899225121418025e+120)
		tmp = t_1;
	elseif (x <= -2.866709023809288e-75)
		tmp = fma(t, Float64(Float64(x - y) / Float64(a - t)), x);
	elseif (x <= 1.0663586952609725e+68)
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(a - z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.2899225121418025e+120], t$95$1, If[LessEqual[x, -2.866709023809288e-75], N[(t * N[(N[(x - y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[x, 1.0663586952609725e+68], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET t_1 = (((a - z) / (a - t)) * x) IN
		LET tmp_2 = IF (x <= (106635869526097248233752503401409679460595265414512810594775462838272)) THEN (y * ((z - t) / (a - t))) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (x <= (-2866709023809288245067103658799511971720731155593317427267209271047651757333440281211625886259030707125666951884687164900873312351586485280715592599857541724637058952585981308457333395327271130526014530914835631847381591796875e-300)) THEN ((t * ((x - y) / (a - t))) + x) ELSE tmp_2 ENDIF IN
		LET tmp = IF (x <= (-1289922512141802462898240206071482538309278126909236030587147305312290175779142154726124748949639666485812944017280729088)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if x < -1.2899225121418025e120 or 1.0663586952609725e68 < x

   1. Initial program 68.2%

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

   3. Applied rewrites 72.1%

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

   4. Taylor expanded in x around -inf

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

   6. Applied rewrites 51.1%

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

   8. Applied rewrites 51.1%

      \[\leadsto \frac{a - z}{a - t} \cdot x \]

   if -1.2899225121418025e120 < x < -2.8667090238092882e-75

   1. Initial program 68.2%

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

   3. Applied rewrites 80.2%

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

   4. Taylor expanded in z around 0

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

   6. Applied rewrites 45.9%

      \[\leadsto \mathsf{fma}\left(t, \frac{x - y}{a - t}, x\right) \]

   if -2.8667090238092882e-75 < x < 1.0663586952609725e68

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   6. Applied rewrites 51.8%

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

Alternative 8: 70.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := \frac{a - z}{a - t} \cdot x\\ \mathbf{if}\;x \leq -1.946982479027504 \cdot 10^{-34}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq 1.0663586952609725 \cdot 10^{+68}:\\ \;\;\;\;y \cdot \frac{z - t}{a - t}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ (- a z) (- a t)) x)))
  (if (<= x -1.946982479027504e-34)
    t_1
    (if (<= x 1.0663586952609725e+68) (* y (/ (- z t) (- a t))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = ((a - z) / (a - t)) * x;
	double tmp;
	if (x <= -1.946982479027504e-34) {
		tmp = t_1;
	} else if (x <= 1.0663586952609725e+68) {
		tmp = y * ((z - t) / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: t_1
    real(8) :: tmp
    t_1 = ((a - z) / (a - t)) * x
    if (x <= (-1.946982479027504d-34)) then
        tmp = t_1
    else if (x <= 1.0663586952609725d+68) then
        tmp = y * ((z - t) / (a - t))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = ((a - z) / (a - t)) * x;
	double tmp;
	if (x <= -1.946982479027504e-34) {
		tmp = t_1;
	} else if (x <= 1.0663586952609725e+68) {
		tmp = y * ((z - t) / (a - t));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = ((a - z) / (a - t)) * x
	tmp = 0
	if x <= -1.946982479027504e-34:
		tmp = t_1
	elif x <= 1.0663586952609725e+68:
		tmp = y * ((z - t) / (a - t))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(Float64(a - z) / Float64(a - t)) * x)
	tmp = 0.0
	if (x <= -1.946982479027504e-34)
		tmp = t_1;
	elseif (x <= 1.0663586952609725e+68)
		tmp = Float64(y * Float64(Float64(z - t) / Float64(a - t)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = ((a - z) / (a - t)) * x;
	tmp = 0.0;
	if (x <= -1.946982479027504e-34)
		tmp = t_1;
	elseif (x <= 1.0663586952609725e+68)
		tmp = y * ((z - t) / (a - t));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(a - z), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.946982479027504e-34], t$95$1, If[LessEqual[x, 1.0663586952609725e+68], N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if x < -1.946982479027504e-34 or 1.0663586952609725e68 < x

   1. Initial program 68.2%

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

   3. Applied rewrites 72.1%

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

   4. Taylor expanded in x around -inf

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

   6. Applied rewrites 51.1%

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

   8. Applied rewrites 51.1%

      \[\leadsto \frac{a - z}{a - t} \cdot x \]

   if -1.946982479027504e-34 < x < 1.0663586952609725e68

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   6. Applied rewrites 51.8%

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

Alternative 9: 66.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} t_1 := y \cdot \frac{z - t}{a - t}\\ \mathbf{if}\;t \leq -3.4840540160521542 \cdot 10^{-15}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 1.572179393643858 \cdot 10^{-136}:\\ \;\;\;\;x + z \cdot \frac{y - x}{a}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* y (/ (- z t) (- a t)))))
  (if (<= t -3.4840540160521542e-15)
    t_1
    (if (<= t 1.572179393643858e-136) (+ x (* z (/ (- y x) a))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double tmp;
	if (t <= -3.4840540160521542e-15) {
		tmp = t_1;
	} else if (t <= 1.572179393643858e-136) {
		tmp = x + (z * ((y - x) / a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: t_1
    real(8) :: tmp
    t_1 = y * ((z - t) / (a - t))
    if (t <= (-3.4840540160521542d-15)) then
        tmp = t_1
    else if (t <= 1.572179393643858d-136) then
        tmp = x + (z * ((y - x) / a))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double t_1 = y * ((z - t) / (a - t));
	double tmp;
	if (t <= -3.4840540160521542e-15) {
		tmp = t_1;
	} else if (t <= 1.572179393643858e-136) {
		tmp = x + (z * ((y - x) / a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	t_1 = y * ((z - t) / (a - t))
	tmp = 0
	if t <= -3.4840540160521542e-15:
		tmp = t_1
	elif t <= 1.572179393643858e-136:
		tmp = x + (z * ((y - x) / a))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(y * Float64(Float64(z - t) / Float64(a - t)))
	tmp = 0.0
	if (t <= -3.4840540160521542e-15)
		tmp = t_1;
	elseif (t <= 1.572179393643858e-136)
		tmp = Float64(x + Float64(z * Float64(Float64(y - x) / a)));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = y * ((z - t) / (a - t));
	tmp = 0.0;
	if (t <= -3.4840540160521542e-15)
		tmp = t_1;
	elseif (t <= 1.572179393643858e-136)
		tmp = x + (z * ((y - x) / a));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.4840540160521542e-15], t$95$1, If[LessEqual[t, 1.572179393643858e-136], N[(x + N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if t < -3.4840540160521542e-15 or 1.5721793936438581e-136 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   6. Applied rewrites 51.8%

      \[\leadsto y \cdot \frac{z - t}{a - t} \]

   if -3.4840540160521542e-15 < t < 1.5721793936438581e-136

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 44.4%

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

   6. Applied rewrites 48.1%

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

Alternative 10: 65.0% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma x (/ a (- a t)) y)))
  (if (<= t -1.3677381906656264e-12)
    t_1
    (if (<= t 6.070281337489173e-52) (+ x (* z (/ (- y x) a))) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma(x, (a / (a - t)), y);
	double tmp;
	if (t <= -1.3677381906656264e-12) {
		tmp = t_1;
	} else if (t <= 6.070281337489173e-52) {
		tmp = x + (z * ((y - x) / a));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = fma(x, Float64(a / Float64(a - t)), y)
	tmp = 0.0
	if (t <= -1.3677381906656264e-12)
		tmp = t_1;
	elseif (t <= 6.070281337489173e-52)
		tmp = Float64(x + Float64(z * Float64(Float64(y - x) / a)));
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if t < -1.3677381906656264e-12 or 6.0702813374891731e-52 < t

   1. Initial program 68.2%

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

   3. Applied rewrites 69.9%

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

   4. Taylor expanded in t around inf

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

   6. Applied rewrites 40.0%

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

   8. Applied rewrites 46.3%

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

   10. Applied rewrites 46.3%

       \[\leadsto \mathsf{fma}\left(x, \frac{a}{a - t}, y\right) \]

   if -1.3677381906656264e-12 < t < 6.0702813374891731e-52

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 44.4%

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

   6. Applied rewrites 48.1%

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

Alternative 11: 62.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \mathbf{if}\;a \leq -2.0488291718295572 \cdot 10^{+58}:\\ \;\;\;\;\mathsf{fma}\left(z - t, \frac{y}{a}, x\right)\\ \mathbf{elif}\;a \leq 5.57771847120369 \cdot 10^{-24}:\\ \;\;\;\;y + \frac{x \cdot \left(z - a\right)}{t}\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(y, \frac{z - t}{a}, x\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= a -2.0488291718295572e+58)
  (fma (- z t) (/ y a) x)
  (if (<= a 5.57771847120369e-24)
    (+ y (/ (* x (- z a)) t))
    (fma y (/ (- z t) a) x))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -2.0488291718295572e+58) {
		tmp = fma((z - t), (y / a), x);
	} else if (a <= 5.57771847120369e-24) {
		tmp = y + ((x * (z - a)) / t);
	} else {
		tmp = fma(y, ((z - t) / a), x);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -2.0488291718295572e+58)
		tmp = fma(Float64(z - t), Float64(y / a), x);
	elseif (a <= 5.57771847120369e-24)
		tmp = Float64(y + Float64(Float64(x * Float64(z - a)) / t));
	else
		tmp = fma(y, Float64(Float64(z - t) / a), x);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -2.0488291718295572e+58], N[(N[(z - t), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, 5.57771847120369e-24], N[(y + N[(N[(x * N[(z - a), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(z - t), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]]]

ReFlow

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

Derivation

1. Split input into 3 regimes

2. if a < -2.0488291718295572e58

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   6. Applied rewrites 52.2%

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

   7. Taylor expanded in x around 0

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

   9. Applied rewrites 44.5%

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

   if -2.0488291718295572e58 < a < 5.5777184712036901e-24

   1. Initial program 68.2%

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

   2. Taylor expanded in t around -inf

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

   4. Applied rewrites 46.2%

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

   5. Taylor expanded in x around -inf

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

   7. Applied rewrites 41.4%

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

   if 5.5777184712036901e-24 < a

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 41.6%

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

   9. Applied rewrites 45.9%

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

Alternative 12: 60.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;a \leq -5.868015255424333 \cdot 10^{-11}:\\ \;\;\;\;\mathsf{fma}\left(z - t, \frac{y}{a}, x\right)\\ \mathbf{elif}\;a \leq -5.049973058012799 \cdot 10^{-46}:\\ \;\;\;\;\frac{x \cdot \left(a - z\right)}{a}\\ \mathbf{elif}\;a \leq 1.2949306076672203 \cdot 10^{-51}:\\ \;\;\;\;\left(1 - \frac{z}{t}\right) \cdot y\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(y, \frac{z - t}{a}, x\right)\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= a -5.868015255424333e-11)
  (fma (- z t) (/ y a) x)
  (if (<= a -5.049973058012799e-46)
    (/ (* x (- a z)) a)
    (if (<= a 1.2949306076672203e-51)
      (* (- 1.0 (/ z t)) y)
      (fma y (/ (- z t) a) x)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (a <= -5.868015255424333e-11) {
		tmp = fma((z - t), (y / a), x);
	} else if (a <= -5.049973058012799e-46) {
		tmp = (x * (a - z)) / a;
	} else if (a <= 1.2949306076672203e-51) {
		tmp = (1.0 - (z / t)) * y;
	} else {
		tmp = fma(y, ((z - t) / a), x);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (a <= -5.868015255424333e-11)
		tmp = fma(Float64(z - t), Float64(y / a), x);
	elseif (a <= -5.049973058012799e-46)
		tmp = Float64(Float64(x * Float64(a - z)) / a);
	elseif (a <= 1.2949306076672203e-51)
		tmp = Float64(Float64(1.0 - Float64(z / t)) * y);
	else
		tmp = fma(y, Float64(Float64(z - t) / a), x);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[a, -5.868015255424333e-11], N[(N[(z - t), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, -5.049973058012799e-46], N[(N[(x * N[(a - z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[a, 1.2949306076672203e-51], N[(N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], N[(y * N[(N[(z - t), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_2 = IF (a <= (1294930607667220275779374814782768339703159830044051713713647863266454185109827229501048535377327472694896247634112494658495609990526975519031793737667612731456756591796875e-222)) THEN (((1) - (z / t)) * y) ELSE ((y * ((z - t) / a)) + x) ENDIF IN
	LET tmp_1 = IF (a <= (-5049973058012799207973559069474634811247316822016761110226254371031803492602393741817990028107879733902644170569218307065284534473903477191925048828125e-196)) THEN ((x * (a - z)) / a) ELSE tmp_2 ENDIF IN
	LET tmp = IF (a <= (-586801525542433303047462801269192576858468868294949061237275600433349609375e-85)) THEN (((z - t) * (y / a)) + x) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 4 regimes

2. if a < -5.868015255424333e-11

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   6. Applied rewrites 52.2%

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

   7. Taylor expanded in x around 0

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

   9. Applied rewrites 44.5%

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

   if -5.868015255424333e-11 < a < -5.0499730580127992e-46

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 26.6%

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

   if -5.0499730580127992e-46 < a < 1.2949306076672203e-51

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   if 1.2949306076672203e-51 < a

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 41.6%

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

   9. Applied rewrites 45.9%

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

Alternative 13: 60.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_1 := \mathsf{fma}\left(y, \frac{z - t}{a}, x\right)\\ \mathbf{if}\;a \leq -5.868015255424333 \cdot 10^{-11}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;a \leq -5.049973058012799 \cdot 10^{-46}:\\ \;\;\;\;\frac{x \cdot \left(a - z\right)}{a}\\ \mathbf{elif}\;a \leq 1.2949306076672203 \cdot 10^{-51}:\\ \;\;\;\;\left(1 - \frac{z}{t}\right) \cdot y\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma y (/ (- z t) a) x)))
  (if (<= a -5.868015255424333e-11)
    t_1
    (if (<= a -5.049973058012799e-46)
      (/ (* x (- a z)) a)
      (if (<= a 1.2949306076672203e-51) (* (- 1.0 (/ z t)) y) t_1)))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma(y, ((z - t) / a), x);
	double tmp;
	if (a <= -5.868015255424333e-11) {
		tmp = t_1;
	} else if (a <= -5.049973058012799e-46) {
		tmp = (x * (a - z)) / a;
	} else if (a <= 1.2949306076672203e-51) {
		tmp = (1.0 - (z / t)) * y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = fma(y, Float64(Float64(z - t) / a), x)
	tmp = 0.0
	if (a <= -5.868015255424333e-11)
		tmp = t_1;
	elseif (a <= -5.049973058012799e-46)
		tmp = Float64(Float64(x * Float64(a - z)) / a);
	elseif (a <= 1.2949306076672203e-51)
		tmp = Float64(Float64(1.0 - Float64(z / t)) * y);
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -5.868015255424333e-11], t$95$1, If[LessEqual[a, -5.049973058012799e-46], N[(N[(x * N[(a - z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[a, 1.2949306076672203e-51], N[(N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET t_1 = ((y * ((z - t) / a)) + x) IN
		LET tmp_2 = IF (a <= (1294930607667220275779374814782768339703159830044051713713647863266454185109827229501048535377327472694896247634112494658495609990526975519031793737667612731456756591796875e-222)) THEN (((1) - (z / t)) * y) ELSE t_1 ENDIF IN
		LET tmp_1 = IF (a <= (-5049973058012799207973559069474634811247316822016761110226254371031803492602393741817990028107879733902644170569218307065284534473903477191925048828125e-196)) THEN ((x * (a - z)) / a) ELSE tmp_2 ENDIF IN
		LET tmp = IF (a <= (-586801525542433303047462801269192576858468868294949061237275600433349609375e-85)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if a < -5.868015255424333e-11 or 1.2949306076672203e-51 < a

   1. Initial program 68.2%

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

   2. Taylor expanded in t around 0

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

   4. Applied rewrites 46.3%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 41.6%

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

   9. Applied rewrites 45.9%

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

   if -5.868015255424333e-11 < a < -5.0499730580127992e-46

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 26.6%

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

   if -5.0499730580127992e-46 < a < 1.2949306076672203e-51

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

Alternative 14: 56.9% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (fma x (/ a (- a t)) y)))
  (if (<= t -3.5804327496357294e-17)
    t_1
    (if (<= t 5.660889824900711e-60) (* (/ (- a z) a) x) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = fma(x, (a / (a - t)), y);
	double tmp;
	if (t <= -3.5804327496357294e-17) {
		tmp = t_1;
	} else if (t <= 5.660889824900711e-60) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t, a)
	t_1 = fma(x, Float64(a / Float64(a - t)), y)
	tmp = 0.0
	if (t <= -3.5804327496357294e-17)
		tmp = t_1;
	elseif (t <= 5.660889824900711e-60)
		tmp = Float64(Float64(Float64(a - z) / a) * x);
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

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

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if t < -3.5804327496357294e-17 or 5.6608898249007106e-60 < t

   1. Initial program 68.2%

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

   3. Applied rewrites 69.9%

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

   4. Taylor expanded in t around inf

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

   6. Applied rewrites 40.0%

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

   8. Applied rewrites 46.3%

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

   10. Applied rewrites 46.3%

       \[\leadsto \mathsf{fma}\left(x, \frac{a}{a - t}, y\right) \]

   if -3.5804327496357294e-17 < t < 5.6608898249007106e-60

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

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

Alternative 15: 51.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -3.706397015076703 \cdot 10^{-17}:\\ \;\;\;\;\left(1 - \frac{z}{t}\right) \cdot y\\ \mathbf{elif}\;t \leq 1.821588670968666 \cdot 10^{-53}:\\ \;\;\;\;\frac{a - z}{a} \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{t - a} \cdot y\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -3.706397015076703e-17)
  (* (- 1.0 (/ z t)) y)
  (if (<= t 1.821588670968666e-53)
    (* (/ (- a z) a) x)
    (* (/ t (- t a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -3.706397015076703e-17) {
		tmp = (1.0 - (z / t)) * y;
	} else if (t <= 1.821588670968666e-53) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = (t / (t - a)) * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (t <= (-3.706397015076703d-17)) then
        tmp = (1.0d0 - (z / t)) * y
    else if (t <= 1.821588670968666d-53) then
        tmp = ((a - z) / a) * x
    else
        tmp = (t / (t - a)) * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -3.706397015076703e-17) {
		tmp = (1.0 - (z / t)) * y;
	} else if (t <= 1.821588670968666e-53) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = (t / (t - a)) * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -3.706397015076703e-17:
		tmp = (1.0 - (z / t)) * y
	elif t <= 1.821588670968666e-53:
		tmp = ((a - z) / a) * x
	else:
		tmp = (t / (t - a)) * y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -3.706397015076703e-17)
		tmp = Float64(Float64(1.0 - Float64(z / t)) * y);
	elseif (t <= 1.821588670968666e-53)
		tmp = Float64(Float64(Float64(a - z) / a) * x);
	else
		tmp = Float64(Float64(t / Float64(t - a)) * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -3.706397015076703e-17)
		tmp = (1.0 - (z / t)) * y;
	elseif (t <= 1.821588670968666e-53)
		tmp = ((a - z) / a) * x;
	else
		tmp = (t / (t - a)) * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -3.706397015076703e-17], N[(N[(1.0 - N[(z / t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, 1.821588670968666e-53], N[(N[(N[(a - z), $MachinePrecision] / a), $MachinePrecision] * x), $MachinePrecision], N[(N[(t / N[(t - a), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_1 = IF (t <= (18215886709686659877040297280524779866780976387778010464525215133771080569984150010564761952152847133461084239313958729776312764369640417871920590187073685228824615478515625e-225)) THEN (((a - z) / a) * x) ELSE ((t / (t - a)) * y) ENDIF IN
	LET tmp = IF (t <= (-370639701507670270304757233203197699827652518422826943833570112474262714385986328125e-100)) THEN (((1) - (z / t)) * y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -3.7063970150767027e-17

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   if -3.7063970150767027e-17 < t < 1.821588670968666e-53

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

      \[\leadsto \frac{a - z}{a} \cdot x \]

   if 1.821588670968666e-53 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   10. Taylor expanded in z around 0

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

   12. Applied rewrites 29.8%

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

Alternative 16: 50.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -3.706397015076703 \cdot 10^{-17}:\\ \;\;\;\;\frac{t - z}{t} \cdot y\\ \mathbf{elif}\;t \leq 1.821588670968666 \cdot 10^{-53}:\\ \;\;\;\;\frac{a - z}{a} \cdot x\\ \mathbf{else}:\\ \;\;\;\;\frac{t}{t - a} \cdot y\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -3.706397015076703e-17)
  (* (/ (- t z) t) y)
  (if (<= t 1.821588670968666e-53)
    (* (/ (- a z) a) x)
    (* (/ t (- t a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -3.706397015076703e-17) {
		tmp = ((t - z) / t) * y;
	} else if (t <= 1.821588670968666e-53) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = (t / (t - a)) * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (t <= (-3.706397015076703d-17)) then
        tmp = ((t - z) / t) * y
    else if (t <= 1.821588670968666d-53) then
        tmp = ((a - z) / a) * x
    else
        tmp = (t / (t - a)) * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -3.706397015076703e-17) {
		tmp = ((t - z) / t) * y;
	} else if (t <= 1.821588670968666e-53) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = (t / (t - a)) * y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -3.706397015076703e-17:
		tmp = ((t - z) / t) * y
	elif t <= 1.821588670968666e-53:
		tmp = ((a - z) / a) * x
	else:
		tmp = (t / (t - a)) * y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -3.706397015076703e-17)
		tmp = Float64(Float64(Float64(t - z) / t) * y);
	elseif (t <= 1.821588670968666e-53)
		tmp = Float64(Float64(Float64(a - z) / a) * x);
	else
		tmp = Float64(Float64(t / Float64(t - a)) * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -3.706397015076703e-17)
		tmp = ((t - z) / t) * y;
	elseif (t <= 1.821588670968666e-53)
		tmp = ((a - z) / a) * x;
	else
		tmp = (t / (t - a)) * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -3.706397015076703e-17], N[(N[(N[(t - z), $MachinePrecision] / t), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, 1.821588670968666e-53], N[(N[(N[(a - z), $MachinePrecision] / a), $MachinePrecision] * x), $MachinePrecision], N[(N[(t / N[(t - a), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_1 = IF (t <= (18215886709686659877040297280524779866780976387778010464525215133771080569984150010564761952152847133461084239313958729776312764369640417871920590187073685228824615478515625e-225)) THEN (((a - z) / a) * x) ELSE ((t / (t - a)) * y) ENDIF IN
	LET tmp = IF (t <= (-370639701507670270304757233203197699827652518422826943833570112474262714385986328125e-100)) THEN (((t - z) / t) * y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -3.7063970150767027e-17

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   10. Taylor expanded in t around 0

       \[\leadsto \frac{t - z}{t} \cdot y \]
   11. Step-by-step derivation

   12. Applied rewrites 36.8%

       \[\leadsto \frac{t - z}{t} \cdot y \]

   if -3.7063970150767027e-17 < t < 1.821588670968666e-53

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

      \[\leadsto \frac{a - z}{a} \cdot x \]

   if 1.821588670968666e-53 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   10. Taylor expanded in z around 0

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

   12. Applied rewrites 29.8%

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

Alternative 17: 50.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_1 := \frac{t - z}{t} \cdot y\\ \mathbf{if}\;t \leq -3.706397015076703 \cdot 10^{-17}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 9.045351731930467 \cdot 10^{-67}:\\ \;\;\;\;\frac{a - z}{a} \cdot x\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* (/ (- t z) t) y)))
  (if (<= t -3.706397015076703e-17)
    t_1
    (if (<= t 9.045351731930467e-67) (* (/ (- a z) a) x) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = ((t - z) / t) * y;
	double tmp;
	if (t <= -3.706397015076703e-17) {
		tmp = t_1;
	} else if (t <= 9.045351731930467e-67) {
		tmp = ((a - z) / a) * x;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Python

def code(x, y, z, t, a):
	t_1 = ((t - z) / t) * y
	tmp = 0
	if t <= -3.706397015076703e-17:
		tmp = t_1
	elif t <= 9.045351731930467e-67:
		tmp = ((a - z) / a) * x
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(Float64(Float64(t - z) / t) * y)
	tmp = 0.0
	if (t <= -3.706397015076703e-17)
		tmp = t_1;
	elseif (t <= 9.045351731930467e-67)
		tmp = Float64(Float64(Float64(a - z) / a) * x);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = ((t - z) / t) * y;
	tmp = 0.0;
	if (t <= -3.706397015076703e-17)
		tmp = t_1;
	elseif (t <= 9.045351731930467e-67)
		tmp = ((a - z) / a) * x;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(t - z), $MachinePrecision] / t), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[t, -3.706397015076703e-17], t$95$1, If[LessEqual[t, 9.045351731930467e-67], N[(N[(N[(a - z), $MachinePrecision] / a), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if t < -3.7063970150767027e-17 or 9.0453517319304669e-67 < t

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 36.8%

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

   9. Applied rewrites 36.8%

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

   10. Taylor expanded in t around 0

       \[\leadsto \frac{t - z}{t} \cdot y \]
   11. Step-by-step derivation

   12. Applied rewrites 36.8%

       \[\leadsto \frac{t - z}{t} \cdot y \]

   if -3.7063970150767027e-17 < t < 9.0453517319304669e-67

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

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

Alternative 18: 47.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -2.5975262133702954 \cdot 10^{+53}:\\ \;\;\;\;y\\ \mathbf{elif}\;t \leq 2.7566530823369742 \cdot 10^{-68}:\\ \;\;\;\;\frac{a - z}{a} \cdot x\\ \mathbf{elif}\;t \leq 1.1008068978610014 \cdot 10^{+48}:\\ \;\;\;\;y \cdot \frac{z - t}{a}\\ \mathbf{else}:\\ \;\;\;\;y\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -2.5975262133702954e+53)
  y
  (if (<= t 2.7566530823369742e-68)
    (* (/ (- a z) a) x)
    (if (<= t 1.1008068978610014e+48) (* y (/ (- z t) a)) y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -2.5975262133702954e+53) {
		tmp = y;
	} else if (t <= 2.7566530823369742e-68) {
		tmp = ((a - z) / a) * x;
	} else if (t <= 1.1008068978610014e+48) {
		tmp = y * ((z - t) / a);
	} else {
		tmp = y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (t <= (-2.5975262133702954d+53)) then
        tmp = y
    else if (t <= 2.7566530823369742d-68) then
        tmp = ((a - z) / a) * x
    else if (t <= 1.1008068978610014d+48) then
        tmp = y * ((z - t) / a)
    else
        tmp = y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -2.5975262133702954e+53) {
		tmp = y;
	} else if (t <= 2.7566530823369742e-68) {
		tmp = ((a - z) / a) * x;
	} else if (t <= 1.1008068978610014e+48) {
		tmp = y * ((z - t) / a);
	} else {
		tmp = y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -2.5975262133702954e+53:
		tmp = y
	elif t <= 2.7566530823369742e-68:
		tmp = ((a - z) / a) * x
	elif t <= 1.1008068978610014e+48:
		tmp = y * ((z - t) / a)
	else:
		tmp = y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -2.5975262133702954e+53)
		tmp = y;
	elseif (t <= 2.7566530823369742e-68)
		tmp = Float64(Float64(Float64(a - z) / a) * x);
	elseif (t <= 1.1008068978610014e+48)
		tmp = Float64(y * Float64(Float64(z - t) / a));
	else
		tmp = y;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -2.5975262133702954e+53)
		tmp = y;
	elseif (t <= 2.7566530823369742e-68)
		tmp = ((a - z) / a) * x;
	elseif (t <= 1.1008068978610014e+48)
		tmp = y * ((z - t) / a);
	else
		tmp = y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2.5975262133702954e+53], y, If[LessEqual[t, 2.7566530823369742e-68], N[(N[(N[(a - z), $MachinePrecision] / a), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[t, 1.1008068978610014e+48], N[(y * N[(N[(z - t), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], y]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_2 = IF (t <= (1100806897861001409486829360205227824465057939456)) THEN (y * ((z - t) / a)) ELSE y ENDIF IN
	LET tmp_1 = IF (t <= (2756653082336974210876901139583537453749262348100114514412238237946291611189124389167204018811955346670744699510833748779381338835697586842931059930680441369138877565590772800163676947704516351222991943359375e-275)) THEN (((a - z) / a) * x) ELSE tmp_2 ENDIF IN
	LET tmp = IF (t <= (-259752621337029535116376460554957704617804645017845760)) THEN y ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if t < -2.5975262133702954e53 or 1.1008068978610014e48 < t

   1. Initial program 68.2%

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

   3. Applied rewrites 67.4%

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

   4. Taylor expanded in t around inf

      \[\leadsto \left(x + -1 \cdot x\right) - -1 \cdot y \]
   5. Step-by-step derivation

   6. Applied rewrites 25.6%

      \[\leadsto \left(x + -1 \cdot x\right) - -1 \cdot y \]

   8. Applied rewrites 25.6%

      \[\leadsto 0 + y \]
   9. Step-by-step derivation

   10. Applied rewrites 25.6%

       \[\leadsto y \]

   if -2.5975262133702954e53 < t < 2.7566530823369742e-68

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

      \[\leadsto \frac{a - z}{a} \cdot x \]

   if 2.7566530823369742e-68 < t < 1.1008068978610014e48

   1. Initial program 68.2%

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

   2. Taylor expanded in y around inf

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

   4. Applied rewrites 51.8%

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

   6. Applied rewrites 51.8%

      \[\leadsto y \cdot \frac{z - t}{a - t} \]

   7. Taylor expanded in a around inf

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

   9. Applied rewrites 23.3%

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

Alternative 19: 41.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -6.964580400987656 \cdot 10^{-13}:\\ \;\;\;\;x + y\\ \mathbf{elif}\;t \leq 2.764006340671492 \cdot 10^{-52}:\\ \;\;\;\;z \cdot \frac{y - x}{a}\\ \mathbf{else}:\\ \;\;\;\;x + y\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -6.964580400987656e-13)
  (+ x y)
  (if (<= t 2.764006340671492e-52) (* z (/ (- y x) a)) (+ x y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -6.964580400987656e-13) {
		tmp = x + y;
	} else if (t <= 2.764006340671492e-52) {
		tmp = z * ((y - x) / a);
	} else {
		tmp = x + y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (t <= (-6.964580400987656d-13)) then
        tmp = x + y
    else if (t <= 2.764006340671492d-52) then
        tmp = z * ((y - x) / a)
    else
        tmp = x + y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -6.964580400987656e-13) {
		tmp = x + y;
	} else if (t <= 2.764006340671492e-52) {
		tmp = z * ((y - x) / a);
	} else {
		tmp = x + y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -6.964580400987656e-13:
		tmp = x + y
	elif t <= 2.764006340671492e-52:
		tmp = z * ((y - x) / a)
	else:
		tmp = x + y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -6.964580400987656e-13)
		tmp = Float64(x + y);
	elseif (t <= 2.764006340671492e-52)
		tmp = Float64(z * Float64(Float64(y - x) / a));
	else
		tmp = Float64(x + y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -6.964580400987656e-13)
		tmp = x + y;
	elseif (t <= 2.764006340671492e-52)
		tmp = z * ((y - x) / a);
	else
		tmp = x + y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -6.964580400987656e-13], N[(x + y), $MachinePrecision], If[LessEqual[t, 2.764006340671492e-52], N[(z * N[(N[(y - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_1 = IF (t <= (27640063406714921248172259477711638357046606100338387929959274470320857591978393947439116081851636604274117317876855248696093861576587868977838979844818823039531707763671875e-224)) THEN (z * ((y - x) / a)) ELSE (x + y) ENDIF IN
	LET tmp = IF (t <= (-696458040098765630167091624822039701184044069304235335948760621249675750732421875e-93)) THEN (x + y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -6.9645804009876563e-13 or 2.7640063406714921e-52 < t

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

   4. Taylor expanded in t around inf

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 19.4%

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 19.4%

      \[\leadsto x + \left(y - x\right) \]

   9. Taylor expanded in x around 0

      \[\leadsto x + y \]
   10. Step-by-step derivation

   11. Applied rewrites 34.8%

       \[\leadsto x + y \]

   if -6.9645804009876563e-13 < t < 2.7640063406714921e-52

   1. Initial program 68.2%

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

   2. Taylor expanded in z around inf

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

   4. Applied rewrites 41.8%

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

   5. Taylor expanded in a around inf

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

   7. Applied rewrites 26.1%

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

Alternative 20: 41.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \mathbf{if}\;z \leq -2.5041685250512675 \cdot 10^{+119}:\\ \;\;\;\;x \cdot \frac{z}{t}\\ \mathbf{elif}\;z \leq 7.604985285304577 \cdot 10^{+99}:\\ \;\;\;\;x + y\\ \mathbf{else}:\\ \;\;\;\;z \cdot \frac{y}{a - t}\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= z -2.5041685250512675e+119)
  (* x (/ z t))
  (if (<= z 7.604985285304577e+99) (+ x y) (* z (/ y (- a t))))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.5041685250512675e+119) {
		tmp = x * (z / t);
	} else if (z <= 7.604985285304577e+99) {
		tmp = x + y;
	} else {
		tmp = z * (y / (a - t));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (z <= (-2.5041685250512675d+119)) then
        tmp = x * (z / t)
    else if (z <= 7.604985285304577d+99) then
        tmp = x + y
    else
        tmp = z * (y / (a - t))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.5041685250512675e+119) {
		tmp = x * (z / t);
	} else if (z <= 7.604985285304577e+99) {
		tmp = x + y;
	} else {
		tmp = z * (y / (a - t));
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -2.5041685250512675e+119:
		tmp = x * (z / t)
	elif z <= 7.604985285304577e+99:
		tmp = x + y
	else:
		tmp = z * (y / (a - t))
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -2.5041685250512675e+119)
		tmp = Float64(x * Float64(z / t));
	elseif (z <= 7.604985285304577e+99)
		tmp = Float64(x + y);
	else
		tmp = Float64(z * Float64(y / Float64(a - t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -2.5041685250512675e+119)
		tmp = x * (z / t);
	elseif (z <= 7.604985285304577e+99)
		tmp = x + y;
	else
		tmp = z * (y / (a - t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.5041685250512675e+119], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.604985285304577e+99], N[(x + y), $MachinePrecision], N[(z * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

ReFlow

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

Derivation

1. Split input into 3 regimes

2. if z < -2.5041685250512675e119

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 16.3%

      \[\leadsto \frac{x \cdot z}{t} \]

   9. Applied rewrites 18.7%

      \[\leadsto x \cdot \frac{z}{t} \]

   if -2.5041685250512675e119 < z < 7.6049852853045773e99

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

   4. Taylor expanded in t around inf

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 19.4%

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 19.4%

      \[\leadsto x + \left(y - x\right) \]

   9. Taylor expanded in x around 0

      \[\leadsto x + y \]
   10. Step-by-step derivation

   11. Applied rewrites 34.8%

       \[\leadsto x + y \]

   if 7.6049852853045773e99 < z

   1. Initial program 68.2%

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

   2. Taylor expanded in z around inf

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

   4. Applied rewrites 41.8%

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

   5. Taylor expanded in x around 0

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

   7. Applied rewrites 23.5%

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

Alternative 21: 39.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \mathbf{if}\;z \leq -2.5041685250512675 \cdot 10^{+119}:\\ \;\;\;\;x \cdot \frac{z}{t}\\ \mathbf{elif}\;z \leq 1.7667715189672238 \cdot 10^{+84}:\\ \;\;\;\;x + y\\ \mathbf{else}:\\ \;\;\;\;z \cdot \frac{x}{t}\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= z -2.5041685250512675e+119)
  (* x (/ z t))
  (if (<= z 1.7667715189672238e+84) (+ x y) (* z (/ x t)))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.5041685250512675e+119) {
		tmp = x * (z / t);
	} else if (z <= 1.7667715189672238e+84) {
		tmp = x + y;
	} else {
		tmp = z * (x / t);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (z <= (-2.5041685250512675d+119)) then
        tmp = x * (z / t)
    else if (z <= 1.7667715189672238d+84) then
        tmp = x + y
    else
        tmp = z * (x / t)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (z <= -2.5041685250512675e+119) {
		tmp = x * (z / t);
	} else if (z <= 1.7667715189672238e+84) {
		tmp = x + y;
	} else {
		tmp = z * (x / t);
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if z <= -2.5041685250512675e+119:
		tmp = x * (z / t)
	elif z <= 1.7667715189672238e+84:
		tmp = x + y
	else:
		tmp = z * (x / t)
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (z <= -2.5041685250512675e+119)
		tmp = Float64(x * Float64(z / t));
	elseif (z <= 1.7667715189672238e+84)
		tmp = Float64(x + y);
	else
		tmp = Float64(z * Float64(x / t));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (z <= -2.5041685250512675e+119)
		tmp = x * (z / t);
	elseif (z <= 1.7667715189672238e+84)
		tmp = x + y;
	else
		tmp = z * (x / t);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.5041685250512675e+119], N[(x * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.7667715189672238e+84], N[(x + y), $MachinePrecision], N[(z * N[(x / t), $MachinePrecision]), $MachinePrecision]]]

ReFlow

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

Derivation

1. Split input into 3 regimes

2. if z < -2.5041685250512675e119

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 16.3%

      \[\leadsto \frac{x \cdot z}{t} \]

   9. Applied rewrites 18.7%

      \[\leadsto x \cdot \frac{z}{t} \]

   if -2.5041685250512675e119 < z < 1.7667715189672238e84

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

   4. Taylor expanded in t around inf

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 19.4%

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 19.4%

      \[\leadsto x + \left(y - x\right) \]

   9. Taylor expanded in x around 0

      \[\leadsto x + y \]
   10. Step-by-step derivation

   11. Applied rewrites 34.8%

       \[\leadsto x + y \]

   if 1.7667715189672238e84 < z

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 16.3%

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

   9. Applied rewrites 17.5%

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

Alternative 22: 38.9% accurate, 1.2× speedup

Math

\[\begin{array}{l} t_1 := z \cdot \frac{x}{t}\\ \mathbf{if}\;z \leq -2.5041685250512675 \cdot 10^{+119}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq 1.7667715189672238 \cdot 10^{+84}:\\ \;\;\;\;x + y\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (* z (/ x t))))
  (if (<= z -2.5041685250512675e+119)
    t_1
    (if (<= z 1.7667715189672238e+84) (+ x y) t_1))))

C

double code(double x, double y, double z, double t, double a) {
	double t_1 = z * (x / t);
	double tmp;
	if (z <= -2.5041685250512675e+119) {
		tmp = t_1;
	} else if (z <= 1.7667715189672238e+84) {
		tmp = x + y;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

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

Python

def code(x, y, z, t, a):
	t_1 = z * (x / t)
	tmp = 0
	if z <= -2.5041685250512675e+119:
		tmp = t_1
	elif z <= 1.7667715189672238e+84:
		tmp = x + y
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a)
	t_1 = Float64(z * Float64(x / t))
	tmp = 0.0
	if (z <= -2.5041685250512675e+119)
		tmp = t_1;
	elseif (z <= 1.7667715189672238e+84)
		tmp = Float64(x + y);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	t_1 = z * (x / t);
	tmp = 0.0;
	if (z <= -2.5041685250512675e+119)
		tmp = t_1;
	elseif (z <= 1.7667715189672238e+84)
		tmp = x + y;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.5041685250512675e+119], t$95$1, If[LessEqual[z, 1.7667715189672238e+84], N[(x + y), $MachinePrecision], t$95$1]]]

ReFlow

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

Derivation

1. Split input into 2 regimes

2. if z < -2.5041685250512675e119 or 1.7667715189672238e84 < z

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   5. Taylor expanded in a around 0

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

   7. Applied rewrites 16.3%

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

   9. Applied rewrites 17.5%

      \[\leadsto z \cdot \frac{x}{t} \]

   if -2.5041685250512675e119 < z < 1.7667715189672238e84

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

   4. Taylor expanded in t around inf

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 19.4%

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 19.4%

      \[\leadsto x + \left(y - x\right) \]

   9. Taylor expanded in x around 0

      \[\leadsto x + y \]
   10. Step-by-step derivation

   11. Applied rewrites 34.8%

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

Alternative 23: 37.8% accurate, 1.6× speedup

Math

\[\begin{array}{l} \mathbf{if}\;t \leq -4.441556525114803 \cdot 10^{-27}:\\ \;\;\;\;x + y\\ \mathbf{elif}\;t \leq 6.733238334788216 \cdot 10^{-93}:\\ \;\;\;\;1 \cdot x\\ \mathbf{else}:\\ \;\;\;\;x + y\\ \end{array} \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (if (<= t -4.441556525114803e-27)
  (+ x y)
  (if (<= t 6.733238334788216e-93) (* 1.0 x) (+ x y))))

C

double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -4.441556525114803e-27) {
		tmp = x + y;
	} else if (t <= 6.733238334788216e-93) {
		tmp = 1.0 * x;
	} else {
		tmp = x + y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a)
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) :: tmp
    if (t <= (-4.441556525114803d-27)) then
        tmp = x + y
    else if (t <= 6.733238334788216d-93) then
        tmp = 1.0d0 * x
    else
        tmp = x + y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a) {
	double tmp;
	if (t <= -4.441556525114803e-27) {
		tmp = x + y;
	} else if (t <= 6.733238334788216e-93) {
		tmp = 1.0 * x;
	} else {
		tmp = x + y;
	}
	return tmp;
}

Python

def code(x, y, z, t, a):
	tmp = 0
	if t <= -4.441556525114803e-27:
		tmp = x + y
	elif t <= 6.733238334788216e-93:
		tmp = 1.0 * x
	else:
		tmp = x + y
	return tmp

Julia

function code(x, y, z, t, a)
	tmp = 0.0
	if (t <= -4.441556525114803e-27)
		tmp = Float64(x + y);
	elseif (t <= 6.733238334788216e-93)
		tmp = Float64(1.0 * x);
	else
		tmp = Float64(x + y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a)
	tmp = 0.0;
	if (t <= -4.441556525114803e-27)
		tmp = x + y;
	elseif (t <= 6.733238334788216e-93)
		tmp = 1.0 * x;
	else
		tmp = x + y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_] := If[LessEqual[t, -4.441556525114803e-27], N[(x + y), $MachinePrecision], If[LessEqual[t, 6.733238334788216e-93], N[(1.0 * x), $MachinePrecision], N[(x + y), $MachinePrecision]]]

ReFlow

f(x, y, z, t, a):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf],
	a in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t, a: real): real =
	LET tmp_1 = IF (t <= (67332383347882156667839560835556315304546657733335957254915619943746149792983234914865523322740449086476337059334590286399030605322605664336104179248002934766220358958785076481886038742479104116359107286482596557612118767463006696605276601985679008066654205322265625e-358)) THEN ((1) * x) ELSE (x + y) ENDIF IN
	LET tmp = IF (t <= (-444155652511480308620201270151736716288533295737111599893235539840308126295631563351662407512776553630828857421875e-140)) THEN (x + y) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if t < -4.4415565251148031e-27 or 6.7332383347882157e-93 < t

   1. Initial program 68.2%

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

   3. Applied rewrites 80.1%

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

   4. Taylor expanded in t around inf

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 19.4%

      \[\leadsto x + -1 \cdot \left(x - y\right) \]
   7. Step-by-step derivation

   8. Applied rewrites 19.4%

      \[\leadsto x + \left(y - x\right) \]

   9. Taylor expanded in x around 0

      \[\leadsto x + y \]
   10. Step-by-step derivation

   11. Applied rewrites 34.8%

       \[\leadsto x + y \]

   if -4.4415565251148031e-27 < t < 6.7332383347882157e-93

   1. Initial program 68.2%

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

   2. Taylor expanded in x around -inf

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

   4. Applied rewrites 47.0%

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

   6. Applied rewrites 47.0%

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

   7. Taylor expanded in t around 0

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

   9. Applied rewrites 36.5%

      \[\leadsto \frac{a - z}{a} \cdot x \]

   10. Taylor expanded in z around 0

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

   12. Applied rewrites 25.4%

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

Alternative 24: 34.8% accurate, 5.1× speedup

Math

\[x + y \]

FPCore

(FPCore (x y z t a)
  :precision binary64
  :pre TRUE
  (+ x y))

C

double code(double x, double y, double z, double t, double a) {
	return x + y;
}

Fortran

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

Java

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

Python

def code(x, y, z, t, a):
	return x + y

Julia

function code(x, y, z, t, a)
	return Float64(x + y)
end

MATLAB

function tmp = code(x, y, z, t, a)
	tmp = x + y;
end

Wolfram

code[x_, y_, z_, t_, a_] := N[(x + y), $MachinePrecision]

ReFlow

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

Derivation

1. Initial program 68.2%

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

3. Applied rewrites 80.1%

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

4. Taylor expanded in t around inf

   \[\leadsto x + -1 \cdot \left(x - y\right) \]
5. Step-by-step derivation

6. Applied rewrites 19.4%

   \[\leadsto x + -1 \cdot \left(x - y\right) \]
7. Step-by-step derivation

8. Applied rewrites 19.4%

   \[\leadsto x + \left(y - x\right) \]

9. Taylor expanded in x around 0

   \[\leadsto x + y \]
10. Step-by-step derivation

11. Applied rewrites 34.8%

    \[\leadsto x + y \]
12. Add Preprocessing

Alternative 25: 25.6% accurate, 18.2× speedup

Math

\[y \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

function code(x, y, z, t, a)
	return y
end

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_] := y

ReFlow

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

Derivation

1. Initial program 68.2%

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

3. Applied rewrites 67.4%

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

4. Taylor expanded in t around inf

   \[\leadsto \left(x + -1 \cdot x\right) - -1 \cdot y \]
5. Step-by-step derivation

6. Applied rewrites 25.6%

   \[\leadsto \left(x + -1 \cdot x\right) - -1 \cdot y \]

8. Applied rewrites 25.6%

   \[\leadsto 0 + y \]
9. Step-by-step derivation

10. Applied rewrites 25.6%

    \[\leadsto y \]
11. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t a)
  :name "Graphics.Rendering.Chart.Axis.Types:linMap from Chart-1.5.3"
  :precision binary64
  (+ x (/ (* (- y x) (- z t)) (- a t))))