Data.Metrics.Snapshot:quantile from metrics-0.3.0.2

Percentage Accurate: 100.0% → 100.0%

Time: 7.1s

Alternatives: 11

Speedup: 1.0×

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

Specification

Math

\[\begin{array}{l} \\ x + \left(y - z\right) \cdot \left(t - x\right) \end{array} \]

FPCore

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

C

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

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) * (t - x))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x + \left(y - z\right) \cdot \left(t - x\right) \end{array} \]

FPCore

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

C

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

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) * (t - x))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x + \left(t - x\right) \cdot \left(y - z\right) \end{array} \]

FPCore

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

C

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

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 + ((t - x) * (y - z))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

   \[x + \left(y - z\right) \cdot \left(t - x\right) \]
2. Add Preprocessing

3. Final simplification 100.0%

   \[\leadsto x + \left(t - x\right) \cdot \left(y - z\right) \]
4. Add Preprocessing

Alternative 2: 54.2% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -7000000000:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq 1.2 \cdot 10^{-84}:\\ \;\;\;\;x + y \cdot t\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{-11}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{elif}\;z \leq 1.26 \cdot 10^{+182} \lor \neg \left(z \leq 9 \cdot 10^{+256}\right):\\ \;\;\;\;x - z \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -7000000000.0)
   (* x z)
   (if (<= z 1.2e-84)
     (+ x (* y t))
     (if (<= z 2.1e-11)
       (* x (- 1.0 y))
       (if (or (<= z 1.26e+182) (not (<= z 9e+256))) (- x (* z t)) (* x z))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -7000000000.0) {
		tmp = x * z;
	} else if (z <= 1.2e-84) {
		tmp = x + (y * t);
	} else if (z <= 2.1e-11) {
		tmp = x * (1.0 - y);
	} else if ((z <= 1.26e+182) || !(z <= 9e+256)) {
		tmp = x - (z * t);
	} else {
		tmp = x * z;
	}
	return tmp;
}

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
    real(8) :: tmp
    if (z <= (-7000000000.0d0)) then
        tmp = x * z
    else if (z <= 1.2d-84) then
        tmp = x + (y * t)
    else if (z <= 2.1d-11) then
        tmp = x * (1.0d0 - y)
    else if ((z <= 1.26d+182) .or. (.not. (z <= 9d+256))) then
        tmp = x - (z * t)
    else
        tmp = x * z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -7000000000.0) {
		tmp = x * z;
	} else if (z <= 1.2e-84) {
		tmp = x + (y * t);
	} else if (z <= 2.1e-11) {
		tmp = x * (1.0 - y);
	} else if ((z <= 1.26e+182) || !(z <= 9e+256)) {
		tmp = x - (z * t);
	} else {
		tmp = x * z;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -7000000000.0:
		tmp = x * z
	elif z <= 1.2e-84:
		tmp = x + (y * t)
	elif z <= 2.1e-11:
		tmp = x * (1.0 - y)
	elif (z <= 1.26e+182) or not (z <= 9e+256):
		tmp = x - (z * t)
	else:
		tmp = x * z
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -7000000000.0)
		tmp = Float64(x * z);
	elseif (z <= 1.2e-84)
		tmp = Float64(x + Float64(y * t));
	elseif (z <= 2.1e-11)
		tmp = Float64(x * Float64(1.0 - y));
	elseif ((z <= 1.26e+182) || !(z <= 9e+256))
		tmp = Float64(x - Float64(z * t));
	else
		tmp = Float64(x * z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -7000000000.0)
		tmp = x * z;
	elseif (z <= 1.2e-84)
		tmp = x + (y * t);
	elseif (z <= 2.1e-11)
		tmp = x * (1.0 - y);
	elseif ((z <= 1.26e+182) || ~((z <= 9e+256)))
		tmp = x - (z * t);
	else
		tmp = x * z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -7000000000.0], N[(x * z), $MachinePrecision], If[LessEqual[z, 1.2e-84], N[(x + N[(y * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.1e-11], N[(x * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 1.26e+182], N[Not[LessEqual[z, 9e+256]], $MachinePrecision]], N[(x - N[(z * t), $MachinePrecision]), $MachinePrecision], N[(x * z), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -7e9 or 1.2600000000000001e182 < z < 8.9999999999999996e256

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 56.4%

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

      1. mul-1-neg 56.4%

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

      2. distribute-rgt-neg-in 56.4%

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

      3. neg-sub0 56.4%

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

      4. sub-neg 56.4%

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

      5. +-commutative 56.4%

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

      6. associate--r+ 56.4%

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

      7. neg-sub0 56.4%

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

      8. remove-double-neg 56.4%

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

   5. Simplified 56.4%

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

      1. sub-neg 56.4%

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

      2. distribute-rgt-in 51.4%

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

   7. Applied egg-rr 51.4%

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

      1. associate-+r+ 51.4%

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

      2. distribute-lft-neg-out 51.4%

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

      3. unsub-neg 51.4%

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

      4. distribute-rgt1-in 51.4%

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

      5. *-commutative 51.4%

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

   9. Applied egg-rr 51.4%

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

   10. Taylor expanded in z around inf 49.3%

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

       1. *-commutative 49.3%

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

   12. Simplified 49.3%

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

   if -7e9 < z < 1.20000000000000009e-84

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 93.2%

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

      1. *-commutative 93.2%

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

   5. Simplified 93.2%

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

   6. Taylor expanded in t around inf 76.6%

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

      1. *-commutative 76.6%

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

   8. Simplified 76.6%

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

   if 1.20000000000000009e-84 < z < 2.0999999999999999e-11

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 84.9%

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

      1. mul-1-neg 84.9%

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

      2. distribute-rgt-neg-in 84.9%

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

      3. neg-sub0 84.9%

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

      4. sub-neg 84.9%

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

      5. +-commutative 84.9%

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

      6. associate--r+ 84.9%

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

      7. neg-sub0 84.9%

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

      8. remove-double-neg 84.9%

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

   5. Simplified 84.9%

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

   6. Taylor expanded in z around 0 84.9%

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

      1. *-rgt-identity 84.9%

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

      2. mul-1-neg 84.9%

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

      3. distribute-rgt-neg-out 84.9%

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

      4. neg-mul-1 84.9%

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

      5. distribute-lft-in 84.9%

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

      6. neg-mul-1 84.9%

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

      7. unsub-neg 84.9%

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

   8. Simplified 84.9%

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

   if 2.0999999999999999e-11 < z < 1.2600000000000001e182 or 8.9999999999999996e256 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 88.8%

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

      1. mul-1-neg 88.8%

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

      2. unsub-neg 88.8%

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

   5. Simplified 88.8%

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

   6. Taylor expanded in t around inf 60.2%

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

      1. *-commutative 60.2%

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

   8. Simplified 60.2%

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

4. Final simplification 65.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7000000000:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq 1.2 \cdot 10^{-84}:\\ \;\;\;\;x + y \cdot t\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{-11}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{elif}\;z \leq 1.26 \cdot 10^{+182} \lor \neg \left(z \leq 9 \cdot 10^{+256}\right):\\ \;\;\;\;x - z \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 38.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.2:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq -3.4 \cdot 10^{-241}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -9.8 \cdot 10^{-291}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;z \leq 8.5 \cdot 10^{-239}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 8500000000:\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -6.2)
   (* x z)
   (if (<= z -3.4e-241)
     x
     (if (<= z -9.8e-291)
       (* y t)
       (if (<= z 8.5e-239) x (if (<= z 8500000000.0) (* y t) (* x z)))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.2) {
		tmp = x * z;
	} else if (z <= -3.4e-241) {
		tmp = x;
	} else if (z <= -9.8e-291) {
		tmp = y * t;
	} else if (z <= 8.5e-239) {
		tmp = x;
	} else if (z <= 8500000000.0) {
		tmp = y * t;
	} else {
		tmp = x * z;
	}
	return tmp;
}

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
    real(8) :: tmp
    if (z <= (-6.2d0)) then
        tmp = x * z
    else if (z <= (-3.4d-241)) then
        tmp = x
    else if (z <= (-9.8d-291)) then
        tmp = y * t
    else if (z <= 8.5d-239) then
        tmp = x
    else if (z <= 8500000000.0d0) then
        tmp = y * t
    else
        tmp = x * z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -6.2) {
		tmp = x * z;
	} else if (z <= -3.4e-241) {
		tmp = x;
	} else if (z <= -9.8e-291) {
		tmp = y * t;
	} else if (z <= 8.5e-239) {
		tmp = x;
	} else if (z <= 8500000000.0) {
		tmp = y * t;
	} else {
		tmp = x * z;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -6.2:
		tmp = x * z
	elif z <= -3.4e-241:
		tmp = x
	elif z <= -9.8e-291:
		tmp = y * t
	elif z <= 8.5e-239:
		tmp = x
	elif z <= 8500000000.0:
		tmp = y * t
	else:
		tmp = x * z
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -6.2)
		tmp = Float64(x * z);
	elseif (z <= -3.4e-241)
		tmp = x;
	elseif (z <= -9.8e-291)
		tmp = Float64(y * t);
	elseif (z <= 8.5e-239)
		tmp = x;
	elseif (z <= 8500000000.0)
		tmp = Float64(y * t);
	else
		tmp = Float64(x * z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -6.2)
		tmp = x * z;
	elseif (z <= -3.4e-241)
		tmp = x;
	elseif (z <= -9.8e-291)
		tmp = y * t;
	elseif (z <= 8.5e-239)
		tmp = x;
	elseif (z <= 8500000000.0)
		tmp = y * t;
	else
		tmp = x * z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -6.2], N[(x * z), $MachinePrecision], If[LessEqual[z, -3.4e-241], x, If[LessEqual[z, -9.8e-291], N[(y * t), $MachinePrecision], If[LessEqual[z, 8.5e-239], x, If[LessEqual[z, 8500000000.0], N[(y * t), $MachinePrecision], N[(x * z), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -6.20000000000000018 or 8.5e9 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 49.3%

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

      1. mul-1-neg 49.3%

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

      2. distribute-rgt-neg-in 49.3%

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

      3. neg-sub0 49.3%

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

      4. sub-neg 49.3%

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

      5. +-commutative 49.3%

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

      6. associate--r+ 49.3%

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

      7. neg-sub0 49.3%

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

      8. remove-double-neg 49.3%

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

   5. Simplified 49.3%

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

      1. sub-neg 49.3%

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

      2. distribute-rgt-in 45.1%

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

   7. Applied egg-rr 45.1%

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

      1. associate-+r+ 45.1%

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

      2. distribute-lft-neg-out 45.1%

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

      3. unsub-neg 45.1%

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

      4. distribute-rgt1-in 45.1%

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

      5. *-commutative 45.1%

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

   9. Applied egg-rr 45.1%

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

   10. Taylor expanded in z around inf 43.0%

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

       1. *-commutative 43.0%

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

   12. Simplified 43.0%

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

   if -6.20000000000000018 < z < -3.3999999999999999e-241 or -9.79999999999999988e-291 < z < 8.49999999999999958e-239

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 91.2%

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

      1. *-commutative 91.2%

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

   5. Simplified 91.2%

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

   6. Taylor expanded in y around 0 45.9%

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

   if -3.3999999999999999e-241 < z < -9.79999999999999988e-291 or 8.49999999999999958e-239 < z < 8.5e9

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 91.6%

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

      1. *-commutative 91.6%

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

   5. Simplified 91.6%

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

   6. Taylor expanded in t around inf 67.0%

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

      1. *-commutative 67.0%

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

   8. Simplified 67.0%

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

   9. Taylor expanded in x around 0 42.7%

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

4. Final simplification 43.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.2:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq -3.4 \cdot 10^{-241}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -9.8 \cdot 10^{-291}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;z \leq 8.5 \cdot 10^{-239}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 8500000000:\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 69.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - t \cdot \left(z - y\right)\\ \mathbf{if}\;t \leq -1.12 \cdot 10^{-160}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 9 \cdot 10^{-284}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-39}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- x (* t (- z y)))))
   (if (<= t -1.12e-160)
     t_1
     (if (<= t 9e-284)
       (* x (- 1.0 y))
       (if (<= t 8.5e-39) (+ x (* x z)) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x - (t * (z - y));
	double tmp;
	if (t <= -1.12e-160) {
		tmp = t_1;
	} else if (t <= 9e-284) {
		tmp = x * (1.0 - y);
	} else if (t <= 8.5e-39) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

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
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x - (t * (z - y))
    if (t <= (-1.12d-160)) then
        tmp = t_1
    else if (t <= 9d-284) then
        tmp = x * (1.0d0 - y)
    else if (t <= 8.5d-39) then
        tmp = x + (x * z)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x - (t * (z - y));
	double tmp;
	if (t <= -1.12e-160) {
		tmp = t_1;
	} else if (t <= 9e-284) {
		tmp = x * (1.0 - y);
	} else if (t <= 8.5e-39) {
		tmp = x + (x * z);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x - (t * (z - y))
	tmp = 0
	if t <= -1.12e-160:
		tmp = t_1
	elif t <= 9e-284:
		tmp = x * (1.0 - y)
	elif t <= 8.5e-39:
		tmp = x + (x * z)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x - Float64(t * Float64(z - y)))
	tmp = 0.0
	if (t <= -1.12e-160)
		tmp = t_1;
	elseif (t <= 9e-284)
		tmp = Float64(x * Float64(1.0 - y));
	elseif (t <= 8.5e-39)
		tmp = Float64(x + Float64(x * z));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x - (t * (z - y));
	tmp = 0.0;
	if (t <= -1.12e-160)
		tmp = t_1;
	elseif (t <= 9e-284)
		tmp = x * (1.0 - y);
	elseif (t <= 8.5e-39)
		tmp = x + (x * z);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x - N[(t * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.12e-160], t$95$1, If[LessEqual[t, 9e-284], N[(x * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e-39], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.11999999999999997e-160 or 8.5000000000000005e-39 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf 83.0%

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

   if -1.11999999999999997e-160 < t < 8.9999999999999999e-284

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 97.4%

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

      1. mul-1-neg 97.4%

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

      2. distribute-rgt-neg-in 97.4%

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

      3. neg-sub0 97.4%

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

      4. sub-neg 97.4%

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

      5. +-commutative 97.4%

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

      6. associate--r+ 97.4%

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

      7. neg-sub0 97.4%

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

      8. remove-double-neg 97.4%

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

   5. Simplified 97.4%

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

   6. Taylor expanded in z around 0 73.4%

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

      1. *-rgt-identity 73.4%

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

      2. mul-1-neg 73.4%

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

      3. distribute-rgt-neg-out 73.4%

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

      4. neg-mul-1 73.4%

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

      5. distribute-lft-in 73.4%

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

      6. neg-mul-1 73.4%

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

      7. unsub-neg 73.4%

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

   8. Simplified 73.4%

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

   if 8.9999999999999999e-284 < t < 8.5000000000000005e-39

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 84.5%

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

      1. mul-1-neg 84.5%

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

      2. distribute-rgt-neg-in 84.5%

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

      3. neg-sub0 84.5%

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

      4. sub-neg 84.5%

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

      5. +-commutative 84.5%

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

      6. associate--r+ 84.5%

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

      7. neg-sub0 84.5%

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

      8. remove-double-neg 84.5%

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

   5. Simplified 84.5%

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

   6. Taylor expanded in y around 0 63.0%

      \[\leadsto \color{blue}{x + x \cdot z} \]
3. Recombined 3 regimes into one program.

4. Final simplification 77.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.12 \cdot 10^{-160}:\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \mathbf{elif}\;t \leq 9 \cdot 10^{-284}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{elif}\;t \leq 8.5 \cdot 10^{-39}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{else}:\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 49.4% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \left(1 - y\right)\\ \mathbf{if}\;y \leq -0.04:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 9 \cdot 10^{-16}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{elif}\;y \leq 6.8 \cdot 10^{+171}:\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* x (- 1.0 y))))
   (if (<= y -0.04)
     t_1
     (if (<= y 9e-16) (+ x (* x z)) (if (<= y 6.8e+171) (* y t) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * (1.0 - y);
	double tmp;
	if (y <= -0.04) {
		tmp = t_1;
	} else if (y <= 9e-16) {
		tmp = x + (x * z);
	} else if (y <= 6.8e+171) {
		tmp = y * t;
	} else {
		tmp = t_1;
	}
	return tmp;
}

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
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x * (1.0d0 - y)
    if (y <= (-0.04d0)) then
        tmp = t_1
    else if (y <= 9d-16) then
        tmp = x + (x * z)
    else if (y <= 6.8d+171) then
        tmp = y * t
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x * (1.0 - y);
	double tmp;
	if (y <= -0.04) {
		tmp = t_1;
	} else if (y <= 9e-16) {
		tmp = x + (x * z);
	} else if (y <= 6.8e+171) {
		tmp = y * t;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x * (1.0 - y)
	tmp = 0
	if y <= -0.04:
		tmp = t_1
	elif y <= 9e-16:
		tmp = x + (x * z)
	elif y <= 6.8e+171:
		tmp = y * t
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x * Float64(1.0 - y))
	tmp = 0.0
	if (y <= -0.04)
		tmp = t_1;
	elseif (y <= 9e-16)
		tmp = Float64(x + Float64(x * z));
	elseif (y <= 6.8e+171)
		tmp = Float64(y * t);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x * (1.0 - y);
	tmp = 0.0;
	if (y <= -0.04)
		tmp = t_1;
	elseif (y <= 9e-16)
		tmp = x + (x * z);
	elseif (y <= 6.8e+171)
		tmp = y * t;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.04], t$95$1, If[LessEqual[y, 9e-16], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.8e+171], N[(y * t), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if y < -0.0400000000000000008 or 6.8000000000000003e171 < y

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 54.8%

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

      1. mul-1-neg 54.8%

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

      2. distribute-rgt-neg-in 54.8%

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

      3. neg-sub0 54.8%

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

      4. sub-neg 54.8%

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

      5. +-commutative 54.8%

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

      6. associate--r+ 54.8%

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

      7. neg-sub0 54.8%

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

      8. remove-double-neg 54.8%

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

   5. Simplified 54.8%

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

   6. Taylor expanded in z around 0 51.1%

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

      1. *-rgt-identity 51.1%

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

      2. mul-1-neg 51.1%

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

      3. distribute-rgt-neg-out 51.1%

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

      4. neg-mul-1 51.1%

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

      5. distribute-lft-in 51.1%

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

      6. neg-mul-1 51.1%

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

      7. unsub-neg 51.1%

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

   8. Simplified 51.1%

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

   if -0.0400000000000000008 < y < 9.0000000000000003e-16

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 60.3%

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

      1. mul-1-neg 60.3%

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

      2. distribute-rgt-neg-in 60.3%

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

      3. neg-sub0 60.3%

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

      4. sub-neg 60.3%

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

      5. +-commutative 60.3%

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

      6. associate--r+ 60.3%

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

      7. neg-sub0 60.3%

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

      8. remove-double-neg 60.3%

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

   5. Simplified 60.3%

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

   6. Taylor expanded in y around 0 59.7%

      \[\leadsto \color{blue}{x + x \cdot z} \]

   if 9.0000000000000003e-16 < y < 6.8000000000000003e171

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 59.8%

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

      1. *-commutative 59.8%

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

   5. Simplified 59.8%

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

   6. Taylor expanded in t around inf 44.9%

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

      1. *-commutative 44.9%

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

   8. Simplified 44.9%

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

   9. Taylor expanded in x around 0 45.1%

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

4. Final simplification 55.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -0.04:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{elif}\;y \leq 9 \cdot 10^{-16}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{elif}\;y \leq 6.8 \cdot 10^{+171}:\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 53.5% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -22000000000000:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq 2 \cdot 10^{-84}:\\ \;\;\;\;x + y \cdot t\\ \mathbf{elif}\;z \leq 6.5:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -22000000000000.0)
   (* x z)
   (if (<= z 2e-84)
     (+ x (* y t))
     (if (<= z 6.5) (* x (- 1.0 y)) (+ x (* x z))))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -22000000000000.0) {
		tmp = x * z;
	} else if (z <= 2e-84) {
		tmp = x + (y * t);
	} else if (z <= 6.5) {
		tmp = x * (1.0 - y);
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

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
    real(8) :: tmp
    if (z <= (-22000000000000.0d0)) then
        tmp = x * z
    else if (z <= 2d-84) then
        tmp = x + (y * t)
    else if (z <= 6.5d0) then
        tmp = x * (1.0d0 - y)
    else
        tmp = x + (x * z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -22000000000000.0) {
		tmp = x * z;
	} else if (z <= 2e-84) {
		tmp = x + (y * t);
	} else if (z <= 6.5) {
		tmp = x * (1.0 - y);
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -22000000000000.0:
		tmp = x * z
	elif z <= 2e-84:
		tmp = x + (y * t)
	elif z <= 6.5:
		tmp = x * (1.0 - y)
	else:
		tmp = x + (x * z)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -22000000000000.0)
		tmp = Float64(x * z);
	elseif (z <= 2e-84)
		tmp = Float64(x + Float64(y * t));
	elseif (z <= 6.5)
		tmp = Float64(x * Float64(1.0 - y));
	else
		tmp = Float64(x + Float64(x * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -22000000000000.0)
		tmp = x * z;
	elseif (z <= 2e-84)
		tmp = x + (y * t);
	elseif (z <= 6.5)
		tmp = x * (1.0 - y);
	else
		tmp = x + (x * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -22000000000000.0], N[(x * z), $MachinePrecision], If[LessEqual[z, 2e-84], N[(x + N[(y * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5], N[(x * N[(1.0 - y), $MachinePrecision]), $MachinePrecision], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if z < -2.2e13

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 52.8%

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

      1. mul-1-neg 52.8%

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

      2. distribute-rgt-neg-in 52.8%

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

      3. neg-sub0 52.8%

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

      4. sub-neg 52.8%

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

      5. +-commutative 52.8%

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

      6. associate--r+ 52.8%

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

      7. neg-sub0 52.8%

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

      8. remove-double-neg 52.8%

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

   5. Simplified 52.8%

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

      1. sub-neg 52.8%

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

      2. distribute-rgt-in 46.4%

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

   7. Applied egg-rr 46.4%

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

      1. associate-+r+ 46.4%

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

      2. distribute-lft-neg-out 46.4%

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

      3. unsub-neg 46.4%

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

      4. distribute-rgt1-in 46.4%

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

      5. *-commutative 46.4%

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

   9. Applied egg-rr 46.4%

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

   10. Taylor expanded in z around inf 45.6%

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

       1. *-commutative 45.6%

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

   12. Simplified 45.6%

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

   if -2.2e13 < z < 2.0000000000000001e-84

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 93.2%

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

      1. *-commutative 93.2%

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

   5. Simplified 93.2%

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

   6. Taylor expanded in t around inf 76.6%

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

      1. *-commutative 76.6%

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

   8. Simplified 76.6%

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

   if 2.0000000000000001e-84 < z < 6.5

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 80.3%

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

      1. mul-1-neg 80.3%

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

      2. distribute-rgt-neg-in 80.3%

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

      3. neg-sub0 80.3%

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

      4. sub-neg 80.3%

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

      5. +-commutative 80.3%

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

      6. associate--r+ 80.3%

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

      7. neg-sub0 80.3%

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

      8. remove-double-neg 80.3%

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

   5. Simplified 80.3%

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

   6. Taylor expanded in z around 0 80.3%

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

      1. *-rgt-identity 80.3%

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

      2. mul-1-neg 80.3%

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

      3. distribute-rgt-neg-out 80.3%

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

      4. neg-mul-1 80.3%

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

      5. distribute-lft-in 80.3%

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

      6. neg-mul-1 80.3%

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

      7. unsub-neg 80.3%

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

   8. Simplified 80.3%

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

   if 6.5 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 45.1%

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

      1. mul-1-neg 45.1%

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

      2. distribute-rgt-neg-in 45.1%

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

      3. neg-sub0 45.1%

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

      4. sub-neg 45.1%

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

      5. +-commutative 45.1%

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

      6. associate--r+ 45.1%

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

      7. neg-sub0 45.1%

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

      8. remove-double-neg 45.1%

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

   5. Simplified 45.1%

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

   6. Taylor expanded in y around 0 39.9%

      \[\leadsto \color{blue}{x + x \cdot z} \]
3. Recombined 4 regimes into one program.

4. Final simplification 60.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -22000000000000:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq 2 \cdot 10^{-84}:\\ \;\;\;\;x + y \cdot t\\ \mathbf{elif}\;z \leq 6.5:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 80.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -0.00055 \lor \neg \left(t \leq 1.5 \cdot 10^{+70}\right):\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot \left(z - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -0.00055) (not (<= t 1.5e+70)))
   (- x (* t (- z y)))
   (+ x (* x (- z y)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -0.00055) || !(t <= 1.5e+70)) {
		tmp = x - (t * (z - y));
	} else {
		tmp = x + (x * (z - y));
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((t <= (-0.00055d0)) .or. (.not. (t <= 1.5d+70))) then
        tmp = x - (t * (z - y))
    else
        tmp = x + (x * (z - y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -0.00055) || !(t <= 1.5e+70)) {
		tmp = x - (t * (z - y));
	} else {
		tmp = x + (x * (z - y));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -0.00055) or not (t <= 1.5e+70):
		tmp = x - (t * (z - y))
	else:
		tmp = x + (x * (z - y))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -0.00055) || !(t <= 1.5e+70))
		tmp = Float64(x - Float64(t * Float64(z - y)));
	else
		tmp = Float64(x + Float64(x * Float64(z - y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t <= -0.00055) || ~((t <= 1.5e+70)))
		tmp = x - (t * (z - y));
	else
		tmp = x + (x * (z - y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -0.00055], N[Not[LessEqual[t, 1.5e+70]], $MachinePrecision]], N[(x - N[(t * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(x * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -5.50000000000000033e-4 or 1.49999999999999988e70 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around inf 91.0%

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

   if -5.50000000000000033e-4 < t < 1.49999999999999988e70

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 83.9%

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

      1. mul-1-neg 83.9%

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

      2. distribute-rgt-neg-in 83.9%

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

      3. neg-sub0 83.9%

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

      4. sub-neg 83.9%

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

      5. +-commutative 83.9%

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

      6. associate--r+ 83.9%

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

      7. neg-sub0 83.9%

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

      8. remove-double-neg 83.9%

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

   5. Simplified 83.9%

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

4. Final simplification 87.3%

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

Alternative 8: 84.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.4 \cdot 10^{-15} \lor \neg \left(z \leq 1.6 \cdot 10^{-8}\right):\\ \;\;\;\;x + z \cdot \left(x - t\right)\\ \mathbf{else}:\\ \;\;\;\;x + y \cdot \left(t - x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= z -2.4e-15) (not (<= z 1.6e-8)))
   (+ x (* z (- x t)))
   (+ x (* y (- t x)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -2.4e-15) || !(z <= 1.6e-8)) {
		tmp = x + (z * (x - t));
	} else {
		tmp = x + (y * (t - x));
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((z <= (-2.4d-15)) .or. (.not. (z <= 1.6d-8))) then
        tmp = x + (z * (x - t))
    else
        tmp = x + (y * (t - x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -2.4e-15) || !(z <= 1.6e-8)) {
		tmp = x + (z * (x - t));
	} else {
		tmp = x + (y * (t - x));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z <= -2.4e-15) or not (z <= 1.6e-8):
		tmp = x + (z * (x - t))
	else:
		tmp = x + (y * (t - x))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((z <= -2.4e-15) || !(z <= 1.6e-8))
		tmp = Float64(x + Float64(z * Float64(x - t)));
	else
		tmp = Float64(x + Float64(y * Float64(t - x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z <= -2.4e-15) || ~((z <= 1.6e-8)))
		tmp = x + (z * (x - t));
	else
		tmp = x + (y * (t - x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[z, -2.4e-15], N[Not[LessEqual[z, 1.6e-8]], $MachinePrecision]], N[(x + N[(z * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -2.39999999999999995e-15 or 1.6000000000000001e-8 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 85.7%

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

      1. mul-1-neg 85.7%

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

      2. unsub-neg 85.7%

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

   5. Simplified 85.7%

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

   if -2.39999999999999995e-15 < z < 1.6000000000000001e-8

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 94.5%

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

      1. *-commutative 94.5%

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

   5. Simplified 94.5%

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

4. Final simplification 90.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.4 \cdot 10^{-15} \lor \neg \left(z \leq 1.6 \cdot 10^{-8}\right):\\ \;\;\;\;x + z \cdot \left(x - t\right)\\ \mathbf{else}:\\ \;\;\;\;x + y \cdot \left(t - x\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 49.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -7.8 \cdot 10^{+16} \lor \neg \left(z \leq 10.2\right):\\ \;\;\;\;x \cdot z\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= z -7.8e+16) (not (<= z 10.2))) (* x z) (* x (- 1.0 y))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -7.8e+16) || !(z <= 10.2)) {
		tmp = x * z;
	} else {
		tmp = x * (1.0 - y);
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((z <= (-7.8d+16)) .or. (.not. (z <= 10.2d0))) then
        tmp = x * z
    else
        tmp = x * (1.0d0 - y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((z <= -7.8e+16) || !(z <= 10.2)) {
		tmp = x * z;
	} else {
		tmp = x * (1.0 - y);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (z <= -7.8e+16) or not (z <= 10.2):
		tmp = x * z
	else:
		tmp = x * (1.0 - y)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((z <= -7.8e+16) || !(z <= 10.2))
		tmp = Float64(x * z);
	else
		tmp = Float64(x * Float64(1.0 - y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((z <= -7.8e+16) || ~((z <= 10.2)))
		tmp = x * z;
	else
		tmp = x * (1.0 - y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[z, -7.8e+16], N[Not[LessEqual[z, 10.2]], $MachinePrecision]], N[(x * z), $MachinePrecision], N[(x * N[(1.0 - y), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -7.8e16 or 10.199999999999999 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 48.2%

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

      1. mul-1-neg 48.2%

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

      2. distribute-rgt-neg-in 48.2%

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

      3. neg-sub0 48.2%

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

      4. sub-neg 48.2%

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

      5. +-commutative 48.2%

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

      6. associate--r+ 48.2%

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

      7. neg-sub0 48.2%

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

      8. remove-double-neg 48.2%

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

   5. Simplified 48.2%

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

      1. sub-neg 48.2%

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

      2. distribute-rgt-in 44.0%

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

   7. Applied egg-rr 44.0%

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

      1. associate-+r+ 44.0%

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

      2. distribute-lft-neg-out 44.0%

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

      3. unsub-neg 44.0%

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

      4. distribute-rgt1-in 44.0%

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

      5. *-commutative 44.0%

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

   9. Applied egg-rr 44.0%

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

   10. Taylor expanded in z around inf 42.5%

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

       1. *-commutative 42.5%

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

   12. Simplified 42.5%

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

   if -7.8e16 < z < 10.199999999999999

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in t around 0 61.6%

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

      1. mul-1-neg 61.6%

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

      2. distribute-rgt-neg-in 61.6%

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

      3. neg-sub0 61.6%

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

      4. sub-neg 61.6%

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

      5. +-commutative 61.6%

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

      6. associate--r+ 61.6%

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

      7. neg-sub0 61.6%

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

      8. remove-double-neg 61.6%

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

   5. Simplified 61.6%

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

   6. Taylor expanded in z around 0 61.0%

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

      1. *-rgt-identity 61.0%

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

      2. mul-1-neg 61.0%

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

      3. distribute-rgt-neg-out 61.0%

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

      4. neg-mul-1 61.0%

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

      5. distribute-lft-in 61.0%

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

      6. neg-mul-1 61.0%

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

      7. unsub-neg 61.0%

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

   8. Simplified 61.0%

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

4. Final simplification 52.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7.8 \cdot 10^{+16} \lor \neg \left(z \leq 10.2\right):\\ \;\;\;\;x \cdot z\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(1 - y\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 30.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -1.12 \cdot 10^{-33} \lor \neg \left(t \leq 9.4 \cdot 10^{+95}\right):\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -1.12e-33) (not (<= t 9.4e+95))) (* y t) x))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -1.12e-33) || !(t <= 9.4e+95)) {
		tmp = y * t;
	} else {
		tmp = x;
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((t <= (-1.12d-33)) .or. (.not. (t <= 9.4d+95))) then
        tmp = y * t
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -1.12e-33) || !(t <= 9.4e+95)) {
		tmp = y * t;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -1.12e-33) or not (t <= 9.4e+95):
		tmp = y * t
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -1.12e-33) || !(t <= 9.4e+95))
		tmp = Float64(y * t);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t <= -1.12e-33) || ~((t <= 9.4e+95)))
		tmp = y * t;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -1.12e-33], N[Not[LessEqual[t, 9.4e+95]], $MachinePrecision]], N[(y * t), $MachinePrecision], x]

Derivation

1. Split input into 2 regimes

2. if t < -1.11999999999999999e-33 or 9.39999999999999945e95 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 56.2%

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

      1. *-commutative 56.2%

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

   5. Simplified 56.2%

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

   6. Taylor expanded in t around inf 50.0%

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

      1. *-commutative 50.0%

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

   8. Simplified 50.0%

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

   9. Taylor expanded in x around 0 42.2%

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

   if -1.11999999999999999e-33 < t < 9.39999999999999945e95

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 59.9%

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

      1. *-commutative 59.9%

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

   5. Simplified 59.9%

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

   6. Taylor expanded in y around 0 32.3%

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

4. Final simplification 37.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.12 \cdot 10^{-33} \lor \neg \left(t \leq 9.4 \cdot 10^{+95}\right):\\ \;\;\;\;y \cdot t\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 17.5% accurate, 9.0× speedup

Math

\[\begin{array}{l} \\ x \end{array} \]

FPCore

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

C

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

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
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := x

Derivation

1. Initial program 100.0%

   \[x + \left(y - z\right) \cdot \left(t - x\right) \]
2. Add Preprocessing

3. Taylor expanded in y around inf 58.1%

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

   1. *-commutative 58.1%

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

5. Simplified 58.1%

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

6. Taylor expanded in y around 0 21.2%

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

7. Final simplification 21.2%

   \[\leadsto x \]
8. Add Preprocessing

Developer target: 96.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ x + \left(t \cdot \left(y - z\right) + \left(-x\right) \cdot \left(y - z\right)\right) \end{array} \]

FPCore

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

C

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

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 + ((t * (y - z)) + (-x * (y - z)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024115 
(FPCore (x y z t)
  :name "Data.Metrics.Snapshot:quantile from metrics-0.3.0.2"
  :precision binary64

  :alt
  (+ x (+ (* t (- y z)) (* (- x) (- y z))))

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