Numeric.Signal.Multichannel:$cput from hsignal-0.2.7.1

Percentage Accurate: 96.9% → 97.1%

Time: 10.3s

Alternatives: 16

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{x - y}{z - y} \cdot t \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (* (/ (- x y) (- z y)) t))

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = ((x - y) / (z - y)) * t
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 96.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - y}{z - y} \cdot t \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (* (/ (- x y) (- z y)) t))

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = ((x - y) / (z - y)) * t
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 97.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_m \leq 4.6 \cdot 10^{+52}:\\ \;\;\;\;\frac{t\_m}{\frac{z - y}{x - y}}\\ \mathbf{else}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t\_m}{z - y}\\ \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (*
  t_s
  (if (<= t_m 4.6e+52)
    (/ t_m (/ (- z y) (- x y)))
    (* (- x y) (/ t_m (- z y))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double tmp;
	if (t_m <= 4.6e+52) {
		tmp = t_m / ((z - y) / (x - y));
	} else {
		tmp = (x - y) * (t_m / (z - y));
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: tmp
    if (t_m <= 4.6d+52) then
        tmp = t_m / ((z - y) / (x - y))
    else
        tmp = (x - y) * (t_m / (z - y))
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double tmp;
	if (t_m <= 4.6e+52) {
		tmp = t_m / ((z - y) / (x - y));
	} else {
		tmp = (x - y) * (t_m / (z - y));
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	tmp = 0
	if t_m <= 4.6e+52:
		tmp = t_m / ((z - y) / (x - y))
	else:
		tmp = (x - y) * (t_m / (z - y))
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	tmp = 0.0
	if (t_m <= 4.6e+52)
		tmp = Float64(t_m / Float64(Float64(z - y) / Float64(x - y)));
	else
		tmp = Float64(Float64(x - y) * Float64(t_m / Float64(z - y)));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	tmp = 0.0;
	if (t_m <= 4.6e+52)
		tmp = t_m / ((z - y) / (x - y));
	else
		tmp = (x - y) * (t_m / (z - y));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := N[(t$95$s * If[LessEqual[t$95$m, 4.6e+52], N[(t$95$m / N[(N[(z - y), $MachinePrecision] / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x - y), $MachinePrecision] * N[(t$95$m / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if t < 4.6e52

   1. Initial program 97.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing
   3. Step-by-step derivation

      1. *-commutative N/A

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

      2. clear-num N/A

         \[\leadsto t \cdot \color{blue}{\frac{1}{\frac{z - y}{x - y}}} \]

      3. un-div-inv N/A

         \[\leadsto \color{blue}{\frac{t}{\frac{z - y}{x - y}}} \]

      4. /-lowering-/.f64 N/A

         \[\leadsto \color{blue}{\frac{t}{\frac{z - y}{x - y}}} \]

      5. /-lowering-/.f64 N/A

         \[\leadsto \frac{t}{\color{blue}{\frac{z - y}{x - y}}} \]

      6. --lowering--.f64 N/A

         \[\leadsto \frac{t}{\frac{\color{blue}{z - y}}{x - y}} \]

      7. --lowering--.f64 97.8

         \[\leadsto \frac{t}{\frac{z - y}{\color{blue}{x - y}}} \]

   4. Applied egg-rr 97.8%

      \[\leadsto \color{blue}{\frac{t}{\frac{z - y}{x - y}}} \]

   if 4.6e52 < t

   1. Initial program 92.8%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing
   3. Step-by-step derivation

      1. associate-*l/ N/A

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

      2. associate-/l* N/A

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

      3. *-commutative N/A

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

      4. *-lowering-*.f64 N/A

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

      5. /-lowering-/.f64 N/A

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

      6. --lowering--.f64 N/A

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

      7. --lowering--.f64 98.1

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

   4. Applied egg-rr 98.1%

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

4. Final simplification 97.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq 4.6 \cdot 10^{+52}:\\ \;\;\;\;\frac{t}{\frac{z - y}{x - y}}\\ \mathbf{else}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 95.6% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z - y}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 0.1:\\ \;\;\;\;t\_m \cdot \frac{x - y}{z}\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;\mathsf{fma}\left(t\_m, \frac{z - x}{y}, t\_m\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x (- z y)))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5000000000000.0)
      t_2
      (if (<= t_3 0.1)
        (* t_m (/ (- x y) z))
        (if (<= t_3 2.0) (fma t_m (/ (- z x) y) t_m) t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 0.1) {
		tmp = t_m * ((x - y) / z);
	} else if (t_3 <= 2.0) {
		tmp = fma(t_m, ((z - x) / y), t_m);
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / Float64(z - y)))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 0.1)
		tmp = Float64(t_m * Float64(Float64(x - y) / z));
	elseif (t_3 <= 2.0)
		tmp = fma(t_m, Float64(Float64(z - x) / y), t_m);
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5000000000000.0], t$95$2, If[LessEqual[t$95$3, 0.1], N[(t$95$m * N[(N[(x - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2.0], N[(t$95$m * N[(N[(z - x), $MachinePrecision] / y), $MachinePrecision] + t$95$m), $MachinePrecision], t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5e12 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.5

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

   5. Simplified 94.5%

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

   if -5e12 < (/.f64 (-.f64 x y) (-.f64 z y)) < 0.10000000000000001

   1. Initial program 94.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

      \[\leadsto \color{blue}{\frac{x - y}{z}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 91.5

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

   5. Simplified 91.5%

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

   if 0.10000000000000001 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

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

      1. associate--l+ N/A

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

      2. distribute-lft-out-- N/A

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

      3. div-sub N/A

         \[\leadsto t + -1 \cdot \color{blue}{\frac{t \cdot x - t \cdot z}{y}} \]

      4. +-commutative N/A

         \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot x - t \cdot z}{y} + t} \]

      5. mul-1-neg N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{t \cdot x - t \cdot z}{y}\right)\right)} + t \]

      6. distribute-lft-out-- N/A

         \[\leadsto \left(\mathsf{neg}\left(\frac{\color{blue}{t \cdot \left(x - z\right)}}{y}\right)\right) + t \]

      7. associate-/l* N/A

         \[\leadsto \left(\mathsf{neg}\left(\color{blue}{t \cdot \frac{x - z}{y}}\right)\right) + t \]

      8. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{t \cdot \left(\mathsf{neg}\left(\frac{x - z}{y}\right)\right)} + t \]

      9. mul-1-neg N/A

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

      10. accelerator-lowering-fma.f64 N/A

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

   5. Simplified 99.6%

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

4. Final simplification 94.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5000000000000:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 0.1:\\ \;\;\;\;t \cdot \frac{x - y}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;\mathsf{fma}\left(t, \frac{z - x}{y}, t\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 95.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z - y}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 0.1:\\ \;\;\;\;t\_m \cdot \frac{x - y}{z}\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;\mathsf{fma}\left(t\_m, \frac{x}{-y}, t\_m\right)\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x (- z y)))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5000000000000.0)
      t_2
      (if (<= t_3 0.1)
        (* t_m (/ (- x y) z))
        (if (<= t_3 2.0) (fma t_m (/ x (- y)) t_m) t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 0.1) {
		tmp = t_m * ((x - y) / z);
	} else if (t_3 <= 2.0) {
		tmp = fma(t_m, (x / -y), t_m);
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / Float64(z - y)))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 0.1)
		tmp = Float64(t_m * Float64(Float64(x - y) / z));
	elseif (t_3 <= 2.0)
		tmp = fma(t_m, Float64(x / Float64(-y)), t_m);
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5000000000000.0], t$95$2, If[LessEqual[t$95$3, 0.1], N[(t$95$m * N[(N[(x - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2.0], N[(t$95$m * N[(x / (-y)), $MachinePrecision] + t$95$m), $MachinePrecision], t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5e12 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.5

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

   5. Simplified 94.5%

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

   if -5e12 < (/.f64 (-.f64 x y) (-.f64 z y)) < 0.10000000000000001

   1. Initial program 94.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

      \[\leadsto \color{blue}{\frac{x - y}{z}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 91.5

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

   5. Simplified 91.5%

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

   if 0.10000000000000001 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot \left(x - y\right)}{y}} \]
   4. Step-by-step derivation

      1. associate-/l* N/A

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

      2. associate-*r* N/A

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

      3. div-sub N/A

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

      4. sub-neg N/A

         \[\leadsto \left(-1 \cdot t\right) \cdot \color{blue}{\left(\frac{x}{y} + \left(\mathsf{neg}\left(\frac{y}{y}\right)\right)\right)} \]

      5. *-inverses N/A

         \[\leadsto \left(-1 \cdot t\right) \cdot \left(\frac{x}{y} + \left(\mathsf{neg}\left(\color{blue}{1}\right)\right)\right) \]

      6. metadata-eval N/A

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

      7. distribute-lft-in N/A

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

      8. neg-mul-1 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(t\right)\right)} \cdot \frac{x}{y} + \left(-1 \cdot t\right) \cdot -1 \]

      9. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(t \cdot \frac{x}{y}\right)\right)} + \left(-1 \cdot t\right) \cdot -1 \]

      10. distribute-rgt-neg-in N/A

          \[\leadsto \color{blue}{t \cdot \left(\mathsf{neg}\left(\frac{x}{y}\right)\right)} + \left(-1 \cdot t\right) \cdot -1 \]

      11. mul-1-neg N/A

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

      12. neg-mul-1 N/A

          \[\leadsto t \cdot \left(-1 \cdot \frac{x}{y}\right) + \color{blue}{\left(\mathsf{neg}\left(t\right)\right)} \cdot -1 \]

      13. distribute-lft-neg-in N/A

          \[\leadsto t \cdot \left(-1 \cdot \frac{x}{y}\right) + \color{blue}{\left(\mathsf{neg}\left(t \cdot -1\right)\right)} \]

      14. *-commutative N/A

          \[\leadsto t \cdot \left(-1 \cdot \frac{x}{y}\right) + \left(\mathsf{neg}\left(\color{blue}{-1 \cdot t}\right)\right) \]

      15. neg-mul-1 N/A

          \[\leadsto t \cdot \left(-1 \cdot \frac{x}{y}\right) + \left(\mathsf{neg}\left(\color{blue}{\left(\mathsf{neg}\left(t\right)\right)}\right)\right) \]

      16. remove-double-neg N/A

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

      17. accelerator-lowering-fma.f64 N/A

          \[\leadsto \color{blue}{\mathsf{fma}\left(t, -1 \cdot \frac{x}{y}, t\right)} \]

      18. mul-1-neg N/A

          \[\leadsto \mathsf{fma}\left(t, \color{blue}{\mathsf{neg}\left(\frac{x}{y}\right)}, t\right) \]

      19. distribute-neg-frac2 N/A

          \[\leadsto \mathsf{fma}\left(t, \color{blue}{\frac{x}{\mathsf{neg}\left(y\right)}}, t\right) \]

      20. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{fma}\left(t, \color{blue}{\frac{x}{\mathsf{neg}\left(y\right)}}, t\right) \]

      21. neg-lowering-neg.f64 99.2

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

   5. Simplified 99.2%

      \[\leadsto \color{blue}{\mathsf{fma}\left(t, \frac{x}{-y}, t\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 94.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5000000000000:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 0.1:\\ \;\;\;\;t \cdot \frac{x - y}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;\mathsf{fma}\left(t, \frac{x}{-y}, t\right)\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 94.9% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z - y}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 0.1:\\ \;\;\;\;t\_m \cdot \frac{x - y}{z}\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x (- z y)))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5000000000000.0)
      t_2
      (if (<= t_3 0.1) (* t_m (/ (- x y) z)) (if (<= t_3 2.0) t_m t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 0.1) {
		tmp = t_m * ((x - y) / z);
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = t_m * (x / (z - y))
    t_3 = (x - y) / (z - y)
    if (t_3 <= (-5000000000000.0d0)) then
        tmp = t_2
    else if (t_3 <= 0.1d0) then
        tmp = t_m * ((x - y) / z)
    else if (t_3 <= 2.0d0) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 0.1) {
		tmp = t_m * ((x - y) / z);
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = t_m * (x / (z - y))
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= -5000000000000.0:
		tmp = t_2
	elif t_3 <= 0.1:
		tmp = t_m * ((x - y) / z)
	elif t_3 <= 2.0:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / Float64(z - y)))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 0.1)
		tmp = Float64(t_m * Float64(Float64(x - y) / z));
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = t_m * (x / (z - y));
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 0.1)
		tmp = t_m * ((x - y) / z);
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5000000000000.0], t$95$2, If[LessEqual[t$95$3, 0.1], N[(t$95$m * N[(N[(x - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2.0], t$95$m, t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5e12 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.5

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

   5. Simplified 94.5%

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

   if -5e12 < (/.f64 (-.f64 x y) (-.f64 z y)) < 0.10000000000000001

   1. Initial program 94.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

      \[\leadsto \color{blue}{\frac{x - y}{z}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 91.5

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

   5. Simplified 91.5%

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

   if 0.10000000000000001 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 95.3%

      \[\leadsto \color{blue}{t} \]
3. Recombined 3 regimes into one program.

4. Final simplification 93.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5000000000000:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 0.1:\\ \;\;\;\;t \cdot \frac{x - y}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 91.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z - y}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x (- z y)))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5000000000000.0)
      t_2
      (if (<= t_3 4e-27) (* (- x y) (/ t_m z)) (if (<= t_3 2.0) t_m t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = t_m * (x / (z - y))
    t_3 = (x - y) / (z - y)
    if (t_3 <= (-5000000000000.0d0)) then
        tmp = t_2
    else if (t_3 <= 4d-27) then
        tmp = (x - y) * (t_m / z)
    else if (t_3 <= 2.0d0) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = t_m * (x / (z - y))
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= -5000000000000.0:
		tmp = t_2
	elif t_3 <= 4e-27:
		tmp = (x - y) * (t_m / z)
	elif t_3 <= 2.0:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / Float64(z - y)))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = Float64(Float64(x - y) * Float64(t_m / z));
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = t_m * (x / (z - y));
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = (x - y) * (t_m / z);
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5000000000000.0], t$95$2, If[LessEqual[t$95$3, 4e-27], N[(N[(x - y), $MachinePrecision] * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2.0], t$95$m, t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5e12 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.5

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

   5. Simplified 94.5%

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

   if -5e12 < (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 94.2%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

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

      1. *-commutative N/A

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

      2. associate-/l* N/A

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

      3. *-lowering-*.f64 N/A

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

      4. --lowering--.f64 N/A

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

      5. /-lowering-/.f64 87.0

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

   5. Simplified 87.0%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 93.2%

      \[\leadsto \color{blue}{t} \]
3. Recombined 3 regimes into one program.

4. Final simplification 91.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5000000000000:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 90.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := x \cdot \frac{t\_m}{z - y}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5000000000000:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_3 \leq 2000:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* x (/ t_m (- z y)))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5000000000000.0)
      t_2
      (if (<= t_3 4e-27)
        (* (- x y) (/ t_m z))
        (if (<= t_3 2000.0) t_m t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = x * (t_m / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_3 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = x * (t_m / (z - y))
    t_3 = (x - y) / (z - y)
    if (t_3 <= (-5000000000000.0d0)) then
        tmp = t_2
    else if (t_3 <= 4d-27) then
        tmp = (x - y) * (t_m / z)
    else if (t_3 <= 2000.0d0) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = x * (t_m / (z - y));
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5000000000000.0) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_3 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = x * (t_m / (z - y))
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= -5000000000000.0:
		tmp = t_2
	elif t_3 <= 4e-27:
		tmp = (x - y) * (t_m / z)
	elif t_3 <= 2000.0:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(x * Float64(t_m / Float64(z - y)))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = Float64(Float64(x - y) * Float64(t_m / z));
	elseif (t_3 <= 2000.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = x * (t_m / (z - y));
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= -5000000000000.0)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = (x - y) * (t_m / z);
	elseif (t_3 <= 2000.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(x * N[(t$95$m / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5000000000000.0], t$95$2, If[LessEqual[t$95$3, 4e-27], N[(N[(x - y), $MachinePrecision] * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2000.0], t$95$m, t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5e12 or 2e3 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.4%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.4

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

   5. Simplified 94.4%

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

      1. *-commutative N/A

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

      2. clear-num N/A

         \[\leadsto t \cdot \color{blue}{\frac{1}{\frac{z - y}{x}}} \]

      3. un-div-inv N/A

         \[\leadsto \color{blue}{\frac{t}{\frac{z - y}{x}}} \]

      4. associate-/r/ N/A

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

      5. *-lowering-*.f64 N/A

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

      6. /-lowering-/.f64 N/A

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

      7. --lowering--.f64 88.2

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

   7. Applied egg-rr 88.2%

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

   if -5e12 < (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 94.2%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

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

      1. *-commutative N/A

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

      2. associate-/l* N/A

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

      3. *-lowering-*.f64 N/A

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

      4. --lowering--.f64 N/A

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

      5. /-lowering-/.f64 87.0

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

   5. Simplified 87.0%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e3

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 92.2%

      \[\leadsto \color{blue}{t} \]
3. Recombined 3 regimes into one program.

4. Final simplification 89.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5000000000000:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2000:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;x \cdot \frac{t}{z - y}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 70.9% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t\_m \cdot \frac{x}{z}\\ \mathbf{elif}\;t\_2 \leq 0.999996:\\ \;\;\;\;y \cdot \frac{t\_m}{y - z}\\ \mathbf{elif}\;t\_2 \leq 2000:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_m \cdot \frac{x}{-y}\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_2 -5e-102)
      (* t_m (/ x z))
      (if (<= t_2 0.999996)
        (* y (/ t_m (- y z)))
        (if (<= t_2 2000.0) t_m (* t_m (/ x (- y)))))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 0.999996) {
		tmp = y * (t_m / (y - z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: tmp
    t_2 = (x - y) / (z - y)
    if (t_2 <= (-5d-102)) then
        tmp = t_m * (x / z)
    else if (t_2 <= 0.999996d0) then
        tmp = y * (t_m / (y - z))
    else if (t_2 <= 2000.0d0) then
        tmp = t_m
    else
        tmp = t_m * (x / -y)
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 0.999996) {
		tmp = y * (t_m / (y - z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = (x - y) / (z - y)
	tmp = 0
	if t_2 <= -5e-102:
		tmp = t_m * (x / z)
	elif t_2 <= 0.999996:
		tmp = y * (t_m / (y - z))
	elif t_2 <= 2000.0:
		tmp = t_m
	else:
		tmp = t_m * (x / -y)
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_2 <= -5e-102)
		tmp = Float64(t_m * Float64(x / z));
	elseif (t_2 <= 0.999996)
		tmp = Float64(y * Float64(t_m / Float64(y - z)));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = Float64(t_m * Float64(x / Float64(-y)));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_2 <= -5e-102)
		tmp = t_m * (x / z);
	elseif (t_2 <= 0.999996)
		tmp = y * (t_m / (y - z));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = t_m * (x / -y);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$2, -5e-102], N[(t$95$m * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.999996], N[(y * N[(t$95$m / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2000.0], t$95$m, N[(t$95$m * N[(x / (-y)), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]

Derivation

1. Split input into 4 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5.00000000000000026e-102

   1. Initial program 96.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 62.4

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

   5. Simplified 62.4%

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

   if -5.00000000000000026e-102 < (/.f64 (-.f64 x y) (-.f64 z y)) < 0.999995999999999996

   1. Initial program 93.5%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot y}{z - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t \cdot y}{z - y}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{y \cdot t}}{z - y}\right) \]

      3. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{y \cdot \frac{t}{z - y}}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{y \cdot \left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      5. mul-1-neg N/A

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

      6. *-lowering-*.f64 N/A

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

      7. mul-1-neg N/A

         \[\leadsto y \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      8. distribute-neg-frac2 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      9. /-lowering-/.f64 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      10. sub-neg N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(z + \left(\mathsf{neg}\left(y\right)\right)\right)}\right)} \]

      11. +-commutative N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(\left(\mathsf{neg}\left(y\right)\right) + z\right)}\right)} \]

      12. distribute-neg-in N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{\left(\mathsf{neg}\left(\left(\mathsf{neg}\left(y\right)\right)\right)\right) + \left(\mathsf{neg}\left(z\right)\right)}} \]

      13. remove-double-neg N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y} + \left(\mathsf{neg}\left(z\right)\right)} \]

      14. +-lowering-+.f64 N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y + \left(\mathsf{neg}\left(z\right)\right)}} \]

      15. neg-lowering-neg.f64 59.0

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

   5. Simplified 59.0%

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

      1. unsub-neg N/A

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

      2. --lowering--.f64 59.0

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

   7. Applied egg-rr 59.0%

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

   if 0.999995999999999996 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e3

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 96.5%

      \[\leadsto \color{blue}{t} \]

   if 2e3 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.6%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.1

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

   5. Simplified 94.1%

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

   6. Taylor expanded in z around 0

      \[\leadsto \frac{x}{\color{blue}{-1 \cdot y}} \cdot t \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \frac{x}{\color{blue}{\mathsf{neg}\left(y\right)}} \cdot t \]

      2. neg-lowering-neg.f64 56.3

         \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]

   8. Simplified 56.3%

      \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]
3. Recombined 4 regimes into one program.

4. Final simplification 70.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 0.999996:\\ \;\;\;\;y \cdot \frac{t}{y - z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2000:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{-y}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 70.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t\_m \cdot \frac{x}{z}\\ \mathbf{elif}\;t\_2 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_2 \leq 2000:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_m \cdot \frac{x}{-y}\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_2 -5e-102)
      (* t_m (/ x z))
      (if (<= t_2 4e-27)
        (- (* y (/ t_m z)))
        (if (<= t_2 2000.0) t_m (* t_m (/ x (- y)))))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: tmp
    t_2 = (x - y) / (z - y)
    if (t_2 <= (-5d-102)) then
        tmp = t_m * (x / z)
    else if (t_2 <= 4d-27) then
        tmp = -(y * (t_m / z))
    else if (t_2 <= 2000.0d0) then
        tmp = t_m
    else
        tmp = t_m * (x / -y)
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = (x - y) / (z - y)
	tmp = 0
	if t_2 <= -5e-102:
		tmp = t_m * (x / z)
	elif t_2 <= 4e-27:
		tmp = -(y * (t_m / z))
	elif t_2 <= 2000.0:
		tmp = t_m
	else:
		tmp = t_m * (x / -y)
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_2 <= -5e-102)
		tmp = Float64(t_m * Float64(x / z));
	elseif (t_2 <= 4e-27)
		tmp = Float64(-Float64(y * Float64(t_m / z)));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = Float64(t_m * Float64(x / Float64(-y)));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_2 <= -5e-102)
		tmp = t_m * (x / z);
	elseif (t_2 <= 4e-27)
		tmp = -(y * (t_m / z));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = t_m * (x / -y);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$2, -5e-102], N[(t$95$m * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e-27], (-N[(y * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision]), If[LessEqual[t$95$2, 2000.0], t$95$m, N[(t$95$m * N[(x / (-y)), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]

Derivation

1. Split input into 4 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5.00000000000000026e-102

   1. Initial program 96.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 62.4

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

   5. Simplified 62.4%

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

   if -5.00000000000000026e-102 < (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 93.1%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot y}{z - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t \cdot y}{z - y}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{y \cdot t}}{z - y}\right) \]

      3. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{y \cdot \frac{t}{z - y}}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{y \cdot \left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      5. mul-1-neg N/A

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

      6. *-lowering-*.f64 N/A

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

      7. mul-1-neg N/A

         \[\leadsto y \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      8. distribute-neg-frac2 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      9. /-lowering-/.f64 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      10. sub-neg N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(z + \left(\mathsf{neg}\left(y\right)\right)\right)}\right)} \]

      11. +-commutative N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(\left(\mathsf{neg}\left(y\right)\right) + z\right)}\right)} \]

      12. distribute-neg-in N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{\left(\mathsf{neg}\left(\left(\mathsf{neg}\left(y\right)\right)\right)\right) + \left(\mathsf{neg}\left(z\right)\right)}} \]

      13. remove-double-neg N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y} + \left(\mathsf{neg}\left(z\right)\right)} \]

      14. +-lowering-+.f64 N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y + \left(\mathsf{neg}\left(z\right)\right)}} \]

      15. neg-lowering-neg.f64 59.3

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

   5. Simplified 59.3%

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

   6. Taylor expanded in y around 0

      \[\leadsto y \cdot \frac{t}{\color{blue}{-1 \cdot z}} \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto y \cdot \frac{t}{\color{blue}{\mathsf{neg}\left(z\right)}} \]

      2. neg-lowering-neg.f64 59.3

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

   8. Simplified 59.3%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e3

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 92.2%

      \[\leadsto \color{blue}{t} \]

   if 2e3 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.6%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.1

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

   5. Simplified 94.1%

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

   6. Taylor expanded in z around 0

      \[\leadsto \frac{x}{\color{blue}{-1 \cdot y}} \cdot t \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \frac{x}{\color{blue}{\mathsf{neg}\left(y\right)}} \cdot t \]

      2. neg-lowering-neg.f64 56.3

         \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]

   8. Simplified 56.3%

      \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]
3. Recombined 4 regimes into one program.

4. Final simplification 69.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2000:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{-y}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 70.0% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t\_m \cdot \frac{x}{z}\\ \mathbf{elif}\;t\_2 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_2 \leq 2000:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;x \cdot \frac{t\_m}{-y}\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_2 -5e-102)
      (* t_m (/ x z))
      (if (<= t_2 4e-27)
        (- (* y (/ t_m z)))
        (if (<= t_2 2000.0) t_m (* x (/ t_m (- y)))))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = x * (t_m / -y);
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: tmp
    t_2 = (x - y) / (z - y)
    if (t_2 <= (-5d-102)) then
        tmp = t_m * (x / z)
    else if (t_2 <= 4d-27) then
        tmp = -(y * (t_m / z))
    else if (t_2 <= 2000.0d0) then
        tmp = t_m
    else
        tmp = x * (t_m / -y)
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= -5e-102) {
		tmp = t_m * (x / z);
	} else if (t_2 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = x * (t_m / -y);
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = (x - y) / (z - y)
	tmp = 0
	if t_2 <= -5e-102:
		tmp = t_m * (x / z)
	elif t_2 <= 4e-27:
		tmp = -(y * (t_m / z))
	elif t_2 <= 2000.0:
		tmp = t_m
	else:
		tmp = x * (t_m / -y)
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_2 <= -5e-102)
		tmp = Float64(t_m * Float64(x / z));
	elseif (t_2 <= 4e-27)
		tmp = Float64(-Float64(y * Float64(t_m / z)));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = Float64(x * Float64(t_m / Float64(-y)));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_2 <= -5e-102)
		tmp = t_m * (x / z);
	elseif (t_2 <= 4e-27)
		tmp = -(y * (t_m / z));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = x * (t_m / -y);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$2, -5e-102], N[(t$95$m * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e-27], (-N[(y * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision]), If[LessEqual[t$95$2, 2000.0], t$95$m, N[(x * N[(t$95$m / (-y)), $MachinePrecision]), $MachinePrecision]]]]), $MachinePrecision]]

Derivation

1. Split input into 4 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5.00000000000000026e-102

   1. Initial program 96.3%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 62.4

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

   5. Simplified 62.4%

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

   if -5.00000000000000026e-102 < (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 93.1%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot y}{z - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t \cdot y}{z - y}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{y \cdot t}}{z - y}\right) \]

      3. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{y \cdot \frac{t}{z - y}}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{y \cdot \left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      5. mul-1-neg N/A

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

      6. *-lowering-*.f64 N/A

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

      7. mul-1-neg N/A

         \[\leadsto y \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      8. distribute-neg-frac2 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      9. /-lowering-/.f64 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      10. sub-neg N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(z + \left(\mathsf{neg}\left(y\right)\right)\right)}\right)} \]

      11. +-commutative N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(\left(\mathsf{neg}\left(y\right)\right) + z\right)}\right)} \]

      12. distribute-neg-in N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{\left(\mathsf{neg}\left(\left(\mathsf{neg}\left(y\right)\right)\right)\right) + \left(\mathsf{neg}\left(z\right)\right)}} \]

      13. remove-double-neg N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y} + \left(\mathsf{neg}\left(z\right)\right)} \]

      14. +-lowering-+.f64 N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y + \left(\mathsf{neg}\left(z\right)\right)}} \]

      15. neg-lowering-neg.f64 59.3

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

   5. Simplified 59.3%

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

   6. Taylor expanded in y around 0

      \[\leadsto y \cdot \frac{t}{\color{blue}{-1 \cdot z}} \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto y \cdot \frac{t}{\color{blue}{\mathsf{neg}\left(z\right)}} \]

      2. neg-lowering-neg.f64 59.3

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

   8. Simplified 59.3%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e3

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 92.2%

      \[\leadsto \color{blue}{t} \]

   if 2e3 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.6%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.1

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

   5. Simplified 94.1%

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

   6. Taylor expanded in z around 0

      \[\leadsto \frac{x}{\color{blue}{-1 \cdot y}} \cdot t \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \frac{x}{\color{blue}{\mathsf{neg}\left(y\right)}} \cdot t \]

      2. neg-lowering-neg.f64 56.3

         \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]

   8. Simplified 56.3%

      \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]
   9. Step-by-step derivation

      1. associate-*l/ N/A

         \[\leadsto \color{blue}{\frac{x \cdot t}{\mathsf{neg}\left(y\right)}} \]

      2. associate-/l* N/A

         \[\leadsto \color{blue}{x \cdot \frac{t}{\mathsf{neg}\left(y\right)}} \]

      3. *-commutative N/A

         \[\leadsto \color{blue}{\frac{t}{\mathsf{neg}\left(y\right)} \cdot x} \]

      4. *-lowering-*.f64 N/A

         \[\leadsto \color{blue}{\frac{t}{\mathsf{neg}\left(y\right)} \cdot x} \]

      5. /-lowering-/.f64 N/A

         \[\leadsto \color{blue}{\frac{t}{\mathsf{neg}\left(y\right)}} \cdot x \]

      6. neg-lowering-neg.f64 53.4

         \[\leadsto \frac{t}{\color{blue}{-y}} \cdot x \]

   10. Applied egg-rr 53.4%

       \[\leadsto \color{blue}{\frac{t}{-y} \cdot x} \]
3. Recombined 4 regimes into one program.

4. Final simplification 69.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2000:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;x \cdot \frac{t}{-y}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 70.5% accurate, 0.3× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x z))) (t_3 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_3 -5e-102)
      t_2
      (if (<= t_3 4e-27) (- (* y (/ t_m z))) (if (<= t_3 2.0) t_m t_2))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5e-102) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = t_m * (x / z)
    t_3 = (x - y) / (z - y)
    if (t_3 <= (-5d-102)) then
        tmp = t_2
    else if (t_3 <= 4d-27) then
        tmp = -(y * (t_m / z))
    else if (t_3 <= 2.0d0) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= -5e-102) {
		tmp = t_2;
	} else if (t_3 <= 4e-27) {
		tmp = -(y * (t_m / z));
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = t_m * (x / z)
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= -5e-102:
		tmp = t_2
	elif t_3 <= 4e-27:
		tmp = -(y * (t_m / z))
	elif t_3 <= 2.0:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / z))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= -5e-102)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = Float64(-Float64(y * Float64(t_m / z)));
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = t_m * (x / z);
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= -5e-102)
		tmp = t_2;
	elseif (t_3 <= 4e-27)
		tmp = -(y * (t_m / z));
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, -5e-102], t$95$2, If[LessEqual[t$95$3, 4e-27], (-N[(y * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision]), If[LessEqual[t$95$3, 2.0], t$95$m, t$95$2]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < -5.00000000000000026e-102 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 96.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 57.3

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

   5. Simplified 57.3%

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

   if -5.00000000000000026e-102 < (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 93.1%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot y}{z - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t \cdot y}{z - y}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{y \cdot t}}{z - y}\right) \]

      3. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{y \cdot \frac{t}{z - y}}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{y \cdot \left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      5. mul-1-neg N/A

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

      6. *-lowering-*.f64 N/A

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

      7. mul-1-neg N/A

         \[\leadsto y \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      8. distribute-neg-frac2 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      9. /-lowering-/.f64 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      10. sub-neg N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(z + \left(\mathsf{neg}\left(y\right)\right)\right)}\right)} \]

      11. +-commutative N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(\left(\mathsf{neg}\left(y\right)\right) + z\right)}\right)} \]

      12. distribute-neg-in N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{\left(\mathsf{neg}\left(\left(\mathsf{neg}\left(y\right)\right)\right)\right) + \left(\mathsf{neg}\left(z\right)\right)}} \]

      13. remove-double-neg N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y} + \left(\mathsf{neg}\left(z\right)\right)} \]

      14. +-lowering-+.f64 N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y + \left(\mathsf{neg}\left(z\right)\right)}} \]

      15. neg-lowering-neg.f64 59.3

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

   5. Simplified 59.3%

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

   6. Taylor expanded in y around 0

      \[\leadsto y \cdot \frac{t}{\color{blue}{-1 \cdot z}} \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto y \cdot \frac{t}{\color{blue}{\mathsf{neg}\left(z\right)}} \]

      2. neg-lowering-neg.f64 59.3

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

   8. Simplified 59.3%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 93.2%

      \[\leadsto \color{blue}{t} \]
3. Recombined 3 regimes into one program.

4. Final simplification 68.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq -5 \cdot 10^{-102}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;-y \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 78.6% accurate, 0.4× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_2 \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t\_m}{z}\\ \mathbf{elif}\;t\_2 \leq 2000:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_m \cdot \frac{x}{-y}\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (/ (- x y) (- z y))))
   (*
    t_s
    (if (<= t_2 4e-27)
      (* (- x y) (/ t_m z))
      (if (<= t_2 2000.0) t_m (* t_m (/ x (- y))))))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: tmp
    t_2 = (x - y) / (z - y)
    if (t_2 <= 4d-27) then
        tmp = (x - y) * (t_m / z)
    else if (t_2 <= 2000.0d0) then
        tmp = t_m
    else
        tmp = t_m * (x / -y)
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = (x - y) / (z - y);
	double tmp;
	if (t_2 <= 4e-27) {
		tmp = (x - y) * (t_m / z);
	} else if (t_2 <= 2000.0) {
		tmp = t_m;
	} else {
		tmp = t_m * (x / -y);
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = (x - y) / (z - y)
	tmp = 0
	if t_2 <= 4e-27:
		tmp = (x - y) * (t_m / z)
	elif t_2 <= 2000.0:
		tmp = t_m
	else:
		tmp = t_m * (x / -y)
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_2 <= 4e-27)
		tmp = Float64(Float64(x - y) * Float64(t_m / z));
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = Float64(t_m * Float64(x / Float64(-y)));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_2 <= 4e-27)
		tmp = (x - y) * (t_m / z);
	elseif (t_2 <= 2000.0)
		tmp = t_m;
	else
		tmp = t_m * (x / -y);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$2, 4e-27], N[(N[(x - y), $MachinePrecision] * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2000.0], t$95$m, N[(t$95$m * N[(x / (-y)), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < 4.0000000000000002e-27

   1. Initial program 94.5%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in z around inf

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

      1. *-commutative N/A

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

      2. associate-/l* N/A

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

      3. *-lowering-*.f64 N/A

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

      4. --lowering--.f64 N/A

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

      5. /-lowering-/.f64 79.8

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

   5. Simplified 79.8%

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

   if 4.0000000000000002e-27 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e3

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 92.2%

      \[\leadsto \color{blue}{t} \]

   if 2e3 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 95.6%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf

      \[\leadsto \color{blue}{\frac{x}{z - y}} \cdot t \]
   4. Step-by-step derivation

      1. /-lowering-/.f64 N/A

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

      2. --lowering--.f64 94.1

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

   5. Simplified 94.1%

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

   6. Taylor expanded in z around 0

      \[\leadsto \frac{x}{\color{blue}{-1 \cdot y}} \cdot t \]
   7. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \frac{x}{\color{blue}{\mathsf{neg}\left(y\right)}} \cdot t \]

      2. neg-lowering-neg.f64 56.3

         \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]

   8. Simplified 56.3%

      \[\leadsto \frac{x}{\color{blue}{-y}} \cdot t \]
3. Recombined 3 regimes into one program.

4. Final simplification 79.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq 4 \cdot 10^{-27}:\\ \;\;\;\;\left(x - y\right) \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2000:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{-y}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 70.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := t\_m \cdot \frac{x}{z}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq 0.001:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 2:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* t_m (/ x z))) (t_3 (/ (- x y) (- z y))))
   (* t_s (if (<= t_3 0.001) t_2 (if (<= t_3 2.0) t_m t_2)))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= 0.001) {
		tmp = t_2;
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = t_m * (x / z)
    t_3 = (x - y) / (z - y)
    if (t_3 <= 0.001d0) then
        tmp = t_2
    else if (t_3 <= 2.0d0) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = t_m * (x / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= 0.001) {
		tmp = t_2;
	} else if (t_3 <= 2.0) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = t_m * (x / z)
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= 0.001:
		tmp = t_2
	elif t_3 <= 2.0:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(t_m * Float64(x / z))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= 0.001)
		tmp = t_2;
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = t_m * (x / z);
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= 0.001)
		tmp = t_2;
	elseif (t_3 <= 2.0)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(t$95$m * N[(x / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, 0.001], t$95$2, If[LessEqual[t$95$3, 2.0], t$95$m, t$95$2]]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < 1e-3 or 2 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 94.9%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 54.1

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

   5. Simplified 54.1%

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

   if 1e-3 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2

   1. Initial program 100.0%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 94.3%

      \[\leadsto \color{blue}{t} \]
3. Recombined 2 regimes into one program.

4. Final simplification 66.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq 0.001:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;t \cdot \frac{x}{z}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 67.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := x \cdot \frac{t\_m}{z}\\ t_3 := \frac{x - y}{z - y}\\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_3 \leq 2 \cdot 10^{-50}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;t\_3 \leq 2 \cdot 10^{+24}:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;t\_2\\ \end{array} \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (let* ((t_2 (* x (/ t_m z))) (t_3 (/ (- x y) (- z y))))
   (* t_s (if (<= t_3 2e-50) t_2 (if (<= t_3 2e+24) t_m t_2)))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = x * (t_m / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= 2e-50) {
		tmp = t_2;
	} else if (t_3 <= 2e+24) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_2 = x * (t_m / z)
    t_3 = (x - y) / (z - y)
    if (t_3 <= 2d-50) then
        tmp = t_2
    else if (t_3 <= 2d+24) then
        tmp = t_m
    else
        tmp = t_2
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double t_2 = x * (t_m / z);
	double t_3 = (x - y) / (z - y);
	double tmp;
	if (t_3 <= 2e-50) {
		tmp = t_2;
	} else if (t_3 <= 2e+24) {
		tmp = t_m;
	} else {
		tmp = t_2;
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	t_2 = x * (t_m / z)
	t_3 = (x - y) / (z - y)
	tmp = 0
	if t_3 <= 2e-50:
		tmp = t_2
	elif t_3 <= 2e+24:
		tmp = t_m
	else:
		tmp = t_2
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	t_2 = Float64(x * Float64(t_m / z))
	t_3 = Float64(Float64(x - y) / Float64(z - y))
	tmp = 0.0
	if (t_3 <= 2e-50)
		tmp = t_2;
	elseif (t_3 <= 2e+24)
		tmp = t_m;
	else
		tmp = t_2;
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	t_2 = x * (t_m / z);
	t_3 = (x - y) / (z - y);
	tmp = 0.0;
	if (t_3 <= 2e-50)
		tmp = t_2;
	elseif (t_3 <= 2e+24)
		tmp = t_m;
	else
		tmp = t_2;
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := Block[{t$95$2 = N[(x * N[(t$95$m / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[t$95$3, 2e-50], t$95$2, If[LessEqual[t$95$3, 2e+24], t$95$m, t$95$2]]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (-.f64 x y) (-.f64 z y)) < 2.00000000000000002e-50 or 2e24 < (/.f64 (-.f64 x y) (-.f64 z y))

   1. Initial program 94.5%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0

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

      1. /-lowering-/.f64 56.0

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

   5. Simplified 56.0%

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

      1. associate-*l/ N/A

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

      2. associate-/l* N/A

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

      3. *-commutative N/A

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

      4. *-lowering-*.f64 N/A

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

      5. /-lowering-/.f64 54.8

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

   7. Applied egg-rr 54.8%

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

   if 2.00000000000000002e-50 < (/.f64 (-.f64 x y) (-.f64 z y)) < 2e24

   1. Initial program 99.9%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 82.9%

      \[\leadsto \color{blue}{t} \]
3. Recombined 2 regimes into one program.

4. Final simplification 64.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x - y}{z - y} \leq 2 \cdot 10^{-50}:\\ \;\;\;\;x \cdot \frac{t}{z}\\ \mathbf{elif}\;\frac{x - y}{z - y} \leq 2 \cdot 10^{+24}:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;x \cdot \frac{t}{z}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 37.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ t\_s \cdot \begin{array}{l} \mathbf{if}\;t\_m \cdot \frac{x - y}{z - y} \leq 5 \cdot 10^{+289}:\\ \;\;\;\;t\_m\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t\_m}{y}\\ \end{array} \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (* t_s (if (<= (* t_m (/ (- x y) (- z y))) 5e+289) t_m (* y (/ t_m y)))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	double tmp;
	if ((t_m * ((x - y) / (z - y))) <= 5e+289) {
		tmp = t_m;
	} else {
		tmp = y * (t_m / y);
	}
	return t_s * tmp;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    real(8) :: tmp
    if ((t_m * ((x - y) / (z - y))) <= 5d+289) then
        tmp = t_m
    else
        tmp = y * (t_m / y)
    end if
    code = t_s * tmp
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	double tmp;
	if ((t_m * ((x - y) / (z - y))) <= 5e+289) {
		tmp = t_m;
	} else {
		tmp = y * (t_m / y);
	}
	return t_s * tmp;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	tmp = 0
	if (t_m * ((x - y) / (z - y))) <= 5e+289:
		tmp = t_m
	else:
		tmp = y * (t_m / y)
	return t_s * tmp

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	tmp = 0.0
	if (Float64(t_m * Float64(Float64(x - y) / Float64(z - y))) <= 5e+289)
		tmp = t_m;
	else
		tmp = Float64(y * Float64(t_m / y));
	end
	return Float64(t_s * tmp)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, x, y, z, t_m)
	tmp = 0.0;
	if ((t_m * ((x - y) / (z - y))) <= 5e+289)
		tmp = t_m;
	else
		tmp = y * (t_m / y);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := N[(t$95$s * If[LessEqual[N[(t$95$m * N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e+289], t$95$m, N[(y * N[(t$95$m / y), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if (*.f64 (/.f64 (-.f64 x y) (-.f64 z y)) t) < 5.00000000000000031e289

   1. Initial program 96.5%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf

      \[\leadsto \color{blue}{t} \]
   4. Step-by-step derivation

   5. Simplified 33.4%

      \[\leadsto \color{blue}{t} \]

   if 5.00000000000000031e289 < (*.f64 (/.f64 (-.f64 x y) (-.f64 z y)) t)

   1. Initial program 94.2%

      \[\frac{x - y}{z - y} \cdot t \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{-1 \cdot \frac{t \cdot y}{z - y}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t \cdot y}{z - y}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{y \cdot t}}{z - y}\right) \]

      3. associate-/l* N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{y \cdot \frac{t}{z - y}}\right) \]

      4. distribute-rgt-neg-in N/A

         \[\leadsto \color{blue}{y \cdot \left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      5. mul-1-neg N/A

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

      6. *-lowering-*.f64 N/A

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

      7. mul-1-neg N/A

         \[\leadsto y \cdot \color{blue}{\left(\mathsf{neg}\left(\frac{t}{z - y}\right)\right)} \]

      8. distribute-neg-frac2 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      9. /-lowering-/.f64 N/A

         \[\leadsto y \cdot \color{blue}{\frac{t}{\mathsf{neg}\left(\left(z - y\right)\right)}} \]

      10. sub-neg N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(z + \left(\mathsf{neg}\left(y\right)\right)\right)}\right)} \]

      11. +-commutative N/A

          \[\leadsto y \cdot \frac{t}{\mathsf{neg}\left(\color{blue}{\left(\left(\mathsf{neg}\left(y\right)\right) + z\right)}\right)} \]

      12. distribute-neg-in N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{\left(\mathsf{neg}\left(\left(\mathsf{neg}\left(y\right)\right)\right)\right) + \left(\mathsf{neg}\left(z\right)\right)}} \]

      13. remove-double-neg N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y} + \left(\mathsf{neg}\left(z\right)\right)} \]

      14. +-lowering-+.f64 N/A

          \[\leadsto y \cdot \frac{t}{\color{blue}{y + \left(\mathsf{neg}\left(z\right)\right)}} \]

      15. neg-lowering-neg.f64 7.8

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

   5. Simplified 7.8%

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

   6. Taylor expanded in y around inf

      \[\leadsto y \cdot \frac{t}{\color{blue}{y}} \]
   7. Step-by-step derivation

   8. Simplified 19.6%

      \[\leadsto y \cdot \frac{t}{\color{blue}{y}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 32.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \cdot \frac{x - y}{z - y} \leq 5 \cdot 10^{+289}:\\ \;\;\;\;t\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{t}{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 15: 96.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ t\_s \cdot \left(t\_m \cdot \frac{x - y}{z - y}\right) \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m)
 :precision binary64
 (* t_s (* t_m (/ (- x y) (- z y)))))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	return t_s * (t_m * ((x - y) / (z - y)));
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    code = t_s * (t_m * ((x - y) / (z - y)))
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	return t_s * (t_m * ((x - y) / (z - y)));
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	return t_s * (t_m * ((x - y) / (z - y)))

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	return Float64(t_s * Float64(t_m * Float64(Float64(x - y) / Float64(z - y))))
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp = code(t_s, x, y, z, t_m)
	tmp = t_s * (t_m * ((x - y) / (z - y)));
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := N[(t$95$s * N[(t$95$m * N[(N[(x - y), $MachinePrecision] / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 96.4%

   \[\frac{x - y}{z - y} \cdot t \]
2. Add Preprocessing

3. Final simplification 96.4%

   \[\leadsto t \cdot \frac{x - y}{z - y} \]
4. Add Preprocessing

Alternative 16: 35.8% accurate, 23.0× speedup

Math

\[\begin{array}{l} t\_m = \left|t\right| \\ t\_s = \mathsf{copysign}\left(1, t\right) \\ t\_s \cdot t\_m \end{array} \]

FPCore

t\_m = (fabs.f64 t)
t\_s = (copysign.f64 #s(literal 1 binary64) t)
(FPCore (t_s x y z t_m) :precision binary64 (* t_s t_m))

C

t\_m = fabs(t);
t\_s = copysign(1.0, t);
double code(double t_s, double x, double y, double z, double t_m) {
	return t_s * t_m;
}

Fortran

t\_m = abs(t)
t\_s = copysign(1.0d0, t)
real(8) function code(t_s, x, y, z, t_m)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t_m
    code = t_s * t_m
end function

Java

t\_m = Math.abs(t);
t\_s = Math.copySign(1.0, t);
public static double code(double t_s, double x, double y, double z, double t_m) {
	return t_s * t_m;
}

Python

t\_m = math.fabs(t)
t\_s = math.copysign(1.0, t)
def code(t_s, x, y, z, t_m):
	return t_s * t_m

Julia

t\_m = abs(t)
t\_s = copysign(1.0, t)
function code(t_s, x, y, z, t_m)
	return Float64(t_s * t_m)
end

MATLAB

t\_m = abs(t);
t\_s = sign(t) * abs(1.0);
function tmp = code(t_s, x, y, z, t_m)
	tmp = t_s * t_m;
end

Wolfram

t\_m = N[Abs[t], $MachinePrecision]
t\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, x_, y_, z_, t$95$m_] := N[(t$95$s * t$95$m), $MachinePrecision]

Derivation

1. Initial program 96.4%

   \[\frac{x - y}{z - y} \cdot t \]
2. Add Preprocessing

3. Taylor expanded in y around inf

   \[\leadsto \color{blue}{t} \]
4. Step-by-step derivation

5. Simplified 31.4%

   \[\leadsto \color{blue}{t} \]
6. Add Preprocessing

Developer Target 1: 96.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \frac{t}{\frac{z - y}{x - y}} \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (/ t (/ (- z y) (- x y))))

C

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

Fortran

real(8) function code(x, y, z, t)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = t / ((z - y) / (x - y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024204 
(FPCore (x y z t)
  :name "Numeric.Signal.Multichannel:$cput from hsignal-0.2.7.1"
  :precision binary64

  :alt
  (! :herbie-platform default (/ t (/ (- z y) (- x y))))

  (* (/ (- x y) (- z y)) t))