Data.Metrics.Snapshot:quantile from metrics-0.3.0.2

Percentage Accurate: 100.0% → 100.0%

Time: 8.0s

Alternatives: 13

Speedup: 1.0×

• 34.9% 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(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]

Derivation

1. Initial program 100.0%

   \[x + \left(y - z\right) \cdot \left(t - x\right) \]

2. Final simplification 100.0%

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

Alternative 2: 76.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x - t \cdot \left(z - y\right)\\ t_2 := x + y \cdot \left(t - x\right)\\ \mathbf{if}\;y \leq -2.9 \cdot 10^{+28}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq 1.85 \cdot 10^{-192}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 2.5 \cdot 10^{-125}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{elif}\;y \leq 1.1 \cdot 10^{+47}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- x (* t (- z y)))) (t_2 (+ x (* y (- t x)))))
   (if (<= y -2.9e+28)
     t_2
     (if (<= y 1.85e-192)
       t_1
       (if (<= y 2.5e-125) (+ x (* x z)) (if (<= y 1.1e+47) t_1 t_2))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x - (t * (z - y));
	double t_2 = x + (y * (t - x));
	double tmp;
	if (y <= -2.9e+28) {
		tmp = t_2;
	} else if (y <= 1.85e-192) {
		tmp = t_1;
	} else if (y <= 2.5e-125) {
		tmp = x + (x * z);
	} else if (y <= 1.1e+47) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	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) :: t_2
    real(8) :: tmp
    t_1 = x - (t * (z - y))
    t_2 = x + (y * (t - x))
    if (y <= (-2.9d+28)) then
        tmp = t_2
    else if (y <= 1.85d-192) then
        tmp = t_1
    else if (y <= 2.5d-125) then
        tmp = x + (x * z)
    else if (y <= 1.1d+47) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x - (t * (z - y));
	double t_2 = x + (y * (t - x));
	double tmp;
	if (y <= -2.9e+28) {
		tmp = t_2;
	} else if (y <= 1.85e-192) {
		tmp = t_1;
	} else if (y <= 2.5e-125) {
		tmp = x + (x * z);
	} else if (y <= 1.1e+47) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x - (t * (z - y))
	t_2 = x + (y * (t - x))
	tmp = 0
	if y <= -2.9e+28:
		tmp = t_2
	elif y <= 1.85e-192:
		tmp = t_1
	elif y <= 2.5e-125:
		tmp = x + (x * z)
	elif y <= 1.1e+47:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x - Float64(t * Float64(z - y)))
	t_2 = Float64(x + Float64(y * Float64(t - x)))
	tmp = 0.0
	if (y <= -2.9e+28)
		tmp = t_2;
	elseif (y <= 1.85e-192)
		tmp = t_1;
	elseif (y <= 2.5e-125)
		tmp = Float64(x + Float64(x * z));
	elseif (y <= 1.1e+47)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x - (t * (z - y));
	t_2 = x + (y * (t - x));
	tmp = 0.0;
	if (y <= -2.9e+28)
		tmp = t_2;
	elseif (y <= 1.85e-192)
		tmp = t_1;
	elseif (y <= 2.5e-125)
		tmp = x + (x * z);
	elseif (y <= 1.1e+47)
		tmp = t_1;
	else
		tmp = t_2;
	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]}, Block[{t$95$2 = N[(x + N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.9e+28], t$95$2, If[LessEqual[y, 1.85e-192], t$95$1, If[LessEqual[y, 2.5e-125], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+47], t$95$1, t$95$2]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -2.9000000000000001e28 or 1.1e47 < y

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in z around 0 84.9%

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

   if -2.9000000000000001e28 < y < 1.85e-192 or 2.49999999999999983e-125 < y < 1.1e47

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 75.6%

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

   if 1.85e-192 < y < 2.49999999999999983e-125

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 93.1%

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

      1. +-commutative 93.1%

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

      2. distribute-rgt1-in 93.1%

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

      3. mul-1-neg 93.1%

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

      4. cancel-sign-sub-inv 93.1%

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

      5. *-commutative 93.1%

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

   4. Simplified 93.1%

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

   5. Taylor expanded in y around 0 93.1%

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

      1. +-commutative 93.1%

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

      2. mul-1-neg 93.1%

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

      3. sub-neg 93.1%

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

      4. mul-1-neg 93.1%

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

   7. Simplified 93.1%

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

   8. Taylor expanded in y around 0 93.1%

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

4. Final simplification 80.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -2.9 \cdot 10^{+28}:\\ \;\;\;\;x + y \cdot \left(t - x\right)\\ \mathbf{elif}\;y \leq 1.85 \cdot 10^{-192}:\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \mathbf{elif}\;y \leq 2.5 \cdot 10^{-125}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{elif}\;y \leq 1.1 \cdot 10^{+47}:\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \mathbf{else}:\\ \;\;\;\;x + y \cdot \left(t - x\right)\\ \end{array} \]

Alternative 3: 36.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := -z \cdot t\\ \mathbf{if}\;t \leq -5.2 \cdot 10^{+102}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;t \leq -1.75 \cdot 10^{-20}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 3 \cdot 10^{-193}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{-94}:\\ \;\;\;\;x \cdot \left(-y\right)\\ \mathbf{elif}\;t \leq 2.32 \cdot 10^{+207}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- (* z t))))
   (if (<= t -5.2e+102)
     (* y t)
     (if (<= t -1.75e-20)
       t_1
       (if (<= t 3e-193)
         (* x z)
         (if (<= t 1.4e-94) (* x (- y)) (if (<= t 2.32e+207) t_1 (* y t))))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = -(z * t);
	double tmp;
	if (t <= -5.2e+102) {
		tmp = y * t;
	} else if (t <= -1.75e-20) {
		tmp = t_1;
	} else if (t <= 3e-193) {
		tmp = x * z;
	} else if (t <= 1.4e-94) {
		tmp = x * -y;
	} else if (t <= 2.32e+207) {
		tmp = t_1;
	} else {
		tmp = y * t;
	}
	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 = -(z * t)
    if (t <= (-5.2d+102)) then
        tmp = y * t
    else if (t <= (-1.75d-20)) then
        tmp = t_1
    else if (t <= 3d-193) then
        tmp = x * z
    else if (t <= 1.4d-94) then
        tmp = x * -y
    else if (t <= 2.32d+207) then
        tmp = t_1
    else
        tmp = y * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = -(z * t);
	double tmp;
	if (t <= -5.2e+102) {
		tmp = y * t;
	} else if (t <= -1.75e-20) {
		tmp = t_1;
	} else if (t <= 3e-193) {
		tmp = x * z;
	} else if (t <= 1.4e-94) {
		tmp = x * -y;
	} else if (t <= 2.32e+207) {
		tmp = t_1;
	} else {
		tmp = y * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = -(z * t)
	tmp = 0
	if t <= -5.2e+102:
		tmp = y * t
	elif t <= -1.75e-20:
		tmp = t_1
	elif t <= 3e-193:
		tmp = x * z
	elif t <= 1.4e-94:
		tmp = x * -y
	elif t <= 2.32e+207:
		tmp = t_1
	else:
		tmp = y * t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(-Float64(z * t))
	tmp = 0.0
	if (t <= -5.2e+102)
		tmp = Float64(y * t);
	elseif (t <= -1.75e-20)
		tmp = t_1;
	elseif (t <= 3e-193)
		tmp = Float64(x * z);
	elseif (t <= 1.4e-94)
		tmp = Float64(x * Float64(-y));
	elseif (t <= 2.32e+207)
		tmp = t_1;
	else
		tmp = Float64(y * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = -(z * t);
	tmp = 0.0;
	if (t <= -5.2e+102)
		tmp = y * t;
	elseif (t <= -1.75e-20)
		tmp = t_1;
	elseif (t <= 3e-193)
		tmp = x * z;
	elseif (t <= 1.4e-94)
		tmp = x * -y;
	elseif (t <= 2.32e+207)
		tmp = t_1;
	else
		tmp = y * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = (-N[(z * t), $MachinePrecision])}, If[LessEqual[t, -5.2e+102], N[(y * t), $MachinePrecision], If[LessEqual[t, -1.75e-20], t$95$1, If[LessEqual[t, 3e-193], N[(x * z), $MachinePrecision], If[LessEqual[t, 1.4e-94], N[(x * (-y)), $MachinePrecision], If[LessEqual[t, 2.32e+207], t$95$1, N[(y * t), $MachinePrecision]]]]]]]

Derivation

1. Split input into 4 regimes

2. if t < -5.20000000000000013e102 or 2.32e207 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 90.9%

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

   3. Taylor expanded in y around inf 60.0%

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

   if -5.20000000000000013e102 < t < -1.75000000000000002e-20 or 1.3999999999999999e-94 < t < 2.32e207

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 72.7%

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

   3. Taylor expanded in z around inf 46.8%

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

      1. mul-1-neg 46.8%

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

      2. distribute-rgt-neg-in 46.8%

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

   5. Simplified 46.8%

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

   if -1.75000000000000002e-20 < t < 2.9999999999999999e-193

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 87.6%

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

      1. +-commutative 87.6%

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

      2. distribute-rgt1-in 87.6%

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

      3. mul-1-neg 87.6%

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

      4. cancel-sign-sub-inv 87.6%

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

      5. *-commutative 87.6%

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

   4. Simplified 87.6%

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

   5. Taylor expanded in z around inf 42.3%

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

   if 2.9999999999999999e-193 < t < 1.3999999999999999e-94

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 68.0%

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

      1. +-commutative 68.0%

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

      2. distribute-rgt1-in 68.0%

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

      3. mul-1-neg 68.0%

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

      4. cancel-sign-sub-inv 68.0%

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

      5. *-commutative 68.0%

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

   4. Simplified 68.0%

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

   5. Taylor expanded in y around inf 42.1%

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

      1. mul-1-neg 42.1%

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

      2. *-commutative 42.1%

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

      3. distribute-rgt-neg-in 42.1%

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

   7. Simplified 42.1%

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

4. Final simplification 48.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -5.2 \cdot 10^{+102}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;t \leq -1.75 \cdot 10^{-20}:\\ \;\;\;\;-z \cdot t\\ \mathbf{elif}\;t \leq 3 \cdot 10^{-193}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;t \leq 1.4 \cdot 10^{-94}:\\ \;\;\;\;x \cdot \left(-y\right)\\ \mathbf{elif}\;t \leq 2.32 \cdot 10^{+207}:\\ \;\;\;\;-z \cdot t\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \]

Alternative 4: 35.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := -z \cdot t\\ \mathbf{if}\;t \leq -2 \cdot 10^{+103}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;t \leq -1.8 \cdot 10^{-20}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;t \leq 3 \cdot 10^{-176}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;t \leq 6 \cdot 10^{+208}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (- (* z t))))
   (if (<= t -2e+103)
     (* y t)
     (if (<= t -1.8e-20)
       t_1
       (if (<= t 3e-176) (* x z) (if (<= t 6e+208) t_1 (* y t)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = -(z * t);
	double tmp;
	if (t <= -2e+103) {
		tmp = y * t;
	} else if (t <= -1.8e-20) {
		tmp = t_1;
	} else if (t <= 3e-176) {
		tmp = x * z;
	} else if (t <= 6e+208) {
		tmp = t_1;
	} else {
		tmp = y * t;
	}
	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 = -(z * t)
    if (t <= (-2d+103)) then
        tmp = y * t
    else if (t <= (-1.8d-20)) then
        tmp = t_1
    else if (t <= 3d-176) then
        tmp = x * z
    else if (t <= 6d+208) then
        tmp = t_1
    else
        tmp = y * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = -(z * t);
	double tmp;
	if (t <= -2e+103) {
		tmp = y * t;
	} else if (t <= -1.8e-20) {
		tmp = t_1;
	} else if (t <= 3e-176) {
		tmp = x * z;
	} else if (t <= 6e+208) {
		tmp = t_1;
	} else {
		tmp = y * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = -(z * t)
	tmp = 0
	if t <= -2e+103:
		tmp = y * t
	elif t <= -1.8e-20:
		tmp = t_1
	elif t <= 3e-176:
		tmp = x * z
	elif t <= 6e+208:
		tmp = t_1
	else:
		tmp = y * t
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(-Float64(z * t))
	tmp = 0.0
	if (t <= -2e+103)
		tmp = Float64(y * t);
	elseif (t <= -1.8e-20)
		tmp = t_1;
	elseif (t <= 3e-176)
		tmp = Float64(x * z);
	elseif (t <= 6e+208)
		tmp = t_1;
	else
		tmp = Float64(y * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = -(z * t);
	tmp = 0.0;
	if (t <= -2e+103)
		tmp = y * t;
	elseif (t <= -1.8e-20)
		tmp = t_1;
	elseif (t <= 3e-176)
		tmp = x * z;
	elseif (t <= 6e+208)
		tmp = t_1;
	else
		tmp = y * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = (-N[(z * t), $MachinePrecision])}, If[LessEqual[t, -2e+103], N[(y * t), $MachinePrecision], If[LessEqual[t, -1.8e-20], t$95$1, If[LessEqual[t, 3e-176], N[(x * z), $MachinePrecision], If[LessEqual[t, 6e+208], t$95$1, N[(y * t), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if t < -2e103 or 5.99999999999999989e208 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 90.9%

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

   3. Taylor expanded in y around inf 60.0%

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

   if -2e103 < t < -1.79999999999999987e-20 or 3e-176 < t < 5.99999999999999989e208

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 70.6%

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

   3. Taylor expanded in z around inf 43.0%

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

      1. mul-1-neg 43.0%

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

      2. distribute-rgt-neg-in 43.0%

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

   5. Simplified 43.0%

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

   if -1.79999999999999987e-20 < t < 3e-176

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 87.5%

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

      1. +-commutative 87.5%

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

      2. distribute-rgt1-in 87.5%

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

      3. mul-1-neg 87.5%

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

      4. cancel-sign-sub-inv 87.5%

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

      5. *-commutative 87.5%

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

   4. Simplified 87.5%

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

   5. Taylor expanded in z around inf 40.4%

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

4. Final simplification 46.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2 \cdot 10^{+103}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;t \leq -1.8 \cdot 10^{-20}:\\ \;\;\;\;-z \cdot t\\ \mathbf{elif}\;t \leq 3 \cdot 10^{-176}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;t \leq 6 \cdot 10^{+208}:\\ \;\;\;\;-z \cdot t\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \]

Alternative 5: 62.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x + x \cdot z\\ \mathbf{if}\;x \leq -4 \cdot 10^{-34}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 8.8 \cdot 10^{+21}:\\ \;\;\;\;\left(y - z\right) \cdot t\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{+186}:\\ \;\;\;\;x - x \cdot y\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ x (* x z))))
   (if (<= x -4e-34)
     t_1
     (if (<= x 8.8e+21)
       (* (- y z) t)
       (if (<= x 1.55e+186) (- x (* x y)) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x + (x * z);
	double tmp;
	if (x <= -4e-34) {
		tmp = t_1;
	} else if (x <= 8.8e+21) {
		tmp = (y - z) * t;
	} else if (x <= 1.55e+186) {
		tmp = x - (x * y);
	} 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 + (x * z)
    if (x <= (-4d-34)) then
        tmp = t_1
    else if (x <= 8.8d+21) then
        tmp = (y - z) * t
    else if (x <= 1.55d+186) then
        tmp = x - (x * y)
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = x + (x * z);
	double tmp;
	if (x <= -4e-34) {
		tmp = t_1;
	} else if (x <= 8.8e+21) {
		tmp = (y - z) * t;
	} else if (x <= 1.55e+186) {
		tmp = x - (x * y);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x + (x * z)
	tmp = 0
	if x <= -4e-34:
		tmp = t_1
	elif x <= 8.8e+21:
		tmp = (y - z) * t
	elif x <= 1.55e+186:
		tmp = x - (x * y)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x + Float64(x * z))
	tmp = 0.0
	if (x <= -4e-34)
		tmp = t_1;
	elseif (x <= 8.8e+21)
		tmp = Float64(Float64(y - z) * t);
	elseif (x <= 1.55e+186)
		tmp = Float64(x - Float64(x * y));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x + (x * z);
	tmp = 0.0;
	if (x <= -4e-34)
		tmp = t_1;
	elseif (x <= 8.8e+21)
		tmp = (y - z) * t;
	elseif (x <= 1.55e+186)
		tmp = x - (x * y);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4e-34], t$95$1, If[LessEqual[x, 8.8e+21], N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 1.55e+186], N[(x - N[(x * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.99999999999999971e-34 or 1.5500000000000001e186 < x

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 82.2%

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

      1. +-commutative 82.2%

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

      2. distribute-rgt1-in 82.2%

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

      3. mul-1-neg 82.2%

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

      4. cancel-sign-sub-inv 82.2%

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

      5. *-commutative 82.2%

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

   4. Simplified 82.2%

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

   5. Taylor expanded in y around 0 80.1%

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

      1. +-commutative 80.1%

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

      2. mul-1-neg 80.1%

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

      3. sub-neg 80.1%

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

      4. mul-1-neg 80.1%

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

   7. Simplified 80.1%

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

   8. Taylor expanded in y around 0 61.2%

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

   if -3.99999999999999971e-34 < x < 8.8e21

   1. Initial program 99.9%

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

      1. flip-+ 51.2%

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

      2. div-inv 51.1%

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

      3. pow2 51.1%

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

   3. Applied egg-rr 51.1%

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

   4. Taylor expanded in t around -inf 100.0%

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

   5. Taylor expanded in x around 0 75.9%

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

   if 8.8e21 < x < 1.5500000000000001e186

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 82.4%

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

      1. +-commutative 82.4%

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

      2. distribute-rgt1-in 82.4%

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

      3. mul-1-neg 82.4%

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

      4. cancel-sign-sub-inv 82.4%

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

      5. *-commutative 82.4%

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

   4. Simplified 82.4%

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

   5. Taylor expanded in z around 0 64.6%

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

4. Final simplification 68.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -4 \cdot 10^{-34}:\\ \;\;\;\;x + x \cdot z\\ \mathbf{elif}\;x \leq 8.8 \cdot 10^{+21}:\\ \;\;\;\;\left(y - z\right) \cdot t\\ \mathbf{elif}\;x \leq 1.55 \cdot 10^{+186}:\\ \;\;\;\;x - x \cdot y\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \]

Alternative 6: 69.8% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -5.2e-107) (not (<= t 1e-190)))
   (- x (* t (- z y)))
   (+ x (* x z))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -5.2e-107) || !(t <= 1e-190)) {
		tmp = x - (t * (z - 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 ((t <= (-5.2d-107)) .or. (.not. (t <= 1d-190))) then
        tmp = x - (t * (z - 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 ((t <= -5.2e-107) || !(t <= 1e-190)) {
		tmp = x - (t * (z - y));
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -5.2e-107) or not (t <= 1e-190):
		tmp = x - (t * (z - y))
	else:
		tmp = x + (x * z)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -5.2e-107) || !(t <= 1e-190))
		tmp = Float64(x - Float64(t * Float64(z - 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 ((t <= -5.2e-107) || ~((t <= 1e-190)))
		tmp = x - (t * (z - y));
	else
		tmp = x + (x * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -5.2e-107], N[Not[LessEqual[t, 1e-190]], $MachinePrecision]], N[(x - N[(t * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -5.2000000000000001e-107 or 1e-190 < t

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 74.1%

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

   if -5.2000000000000001e-107 < t < 1e-190

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 92.3%

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

      1. +-commutative 92.3%

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

      2. distribute-rgt1-in 92.3%

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

      3. mul-1-neg 92.3%

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

      4. cancel-sign-sub-inv 92.3%

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

      5. *-commutative 92.3%

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

   4. Simplified 92.3%

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

   5. Taylor expanded in y around 0 90.8%

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

      1. +-commutative 90.8%

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

      2. mul-1-neg 90.8%

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

      3. sub-neg 90.8%

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

      4. mul-1-neg 90.8%

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

   7. Simplified 90.8%

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

   8. Taylor expanded in y around 0 67.2%

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

4. Final simplification 72.2%

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

Alternative 7: 80.7% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= x -3.8e-33) (not (<= x 3.5e+21)))
   (+ x (* x (- z y)))
   (- x (* t (- z y)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((x <= -3.8e-33) || !(x <= 3.5e+21)) {
		tmp = x + (x * (z - y));
	} else {
		tmp = x - (t * (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 ((x <= (-3.8d-33)) .or. (.not. (x <= 3.5d+21))) then
        tmp = x + (x * (z - y))
    else
        tmp = x - (t * (z - y))
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[x, -3.8e-33], N[Not[LessEqual[x, 3.5e+21]], $MachinePrecision]], N[(x + N[(x * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(t * N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -3.79999999999999994e-33 or 3.5e21 < x

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 82.2%

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

      1. +-commutative 82.2%

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

      2. distribute-rgt1-in 82.2%

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

      3. mul-1-neg 82.2%

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

      4. cancel-sign-sub-inv 82.2%

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

      5. *-commutative 82.2%

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

   4. Simplified 82.2%

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

   if -3.79999999999999994e-33 < x < 3.5e21

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 82.2%

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

4. Final simplification 82.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.8 \cdot 10^{-33} \lor \neg \left(x \leq 3.5 \cdot 10^{+21}\right):\\ \;\;\;\;x + x \cdot \left(z - y\right)\\ \mathbf{else}:\\ \;\;\;\;x - t \cdot \left(z - y\right)\\ \end{array} \]

Alternative 8: 84.6% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= y -1.2e+27) (not (<= y 4e+38)))
   (+ x (* y (- t x)))
   (+ x (* z (- x t)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((y <= -1.2e+27) || !(y <= 4e+38)) {
		tmp = x + (y * (t - x));
	} else {
		tmp = x + (z * (x - t));
	}
	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 ((y <= (-1.2d+27)) .or. (.not. (y <= 4d+38))) then
        tmp = x + (y * (t - x))
    else
        tmp = x + (z * (x - t))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if ((y <= -1.2e+27) || !(y <= 4e+38)) {
		tmp = x + (y * (t - x));
	} else {
		tmp = x + (z * (x - t));
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (y <= -1.2e+27) or not (y <= 4e+38):
		tmp = x + (y * (t - x))
	else:
		tmp = x + (z * (x - t))
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((y <= -1.2e+27) || !(y <= 4e+38))
		tmp = Float64(x + Float64(y * Float64(t - x)));
	else
		tmp = Float64(x + Float64(z * Float64(x - t)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((y <= -1.2e+27) || ~((y <= 4e+38)))
		tmp = x + (y * (t - x));
	else
		tmp = x + (z * (x - t));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[y, -1.2e+27], N[Not[LessEqual[y, 4e+38]], $MachinePrecision]], N[(x + N[(y * N[(t - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(z * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -1.19999999999999999e27 or 3.99999999999999991e38 < y

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in z around 0 84.6%

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

   if -1.19999999999999999e27 < y < 3.99999999999999991e38

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in y around 0 89.6%

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

      1. +-commutative 89.6%

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

      2. mul-1-neg 89.6%

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

      3. unsub-neg 89.6%

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

      4. *-commutative 89.6%

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

   4. Simplified 89.6%

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

4. Final simplification 87.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -1.2 \cdot 10^{+27} \lor \neg \left(y \leq 4 \cdot 10^{+38}\right):\\ \;\;\;\;x + y \cdot \left(t - x\right)\\ \mathbf{else}:\\ \;\;\;\;x + z \cdot \left(x - t\right)\\ \end{array} \]

Alternative 9: 37.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -5.4 \cdot 10^{+38}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq -1.12 \cdot 10^{-265}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;z \leq 16600000000000:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= z -5.4e+38)
   (* x z)
   (if (<= z -1.12e-265) (* y t) (if (<= z 16600000000000.0) x (* x z)))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (z <= -5.4e+38) {
		tmp = x * z;
	} else if (z <= -1.12e-265) {
		tmp = y * t;
	} else if (z <= 16600000000000.0) {
		tmp = x;
	} 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 <= (-5.4d+38)) then
        tmp = x * z
    else if (z <= (-1.12d-265)) then
        tmp = y * t
    else if (z <= 16600000000000.0d0) then
        tmp = x
    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 <= -5.4e+38) {
		tmp = x * z;
	} else if (z <= -1.12e-265) {
		tmp = y * t;
	} else if (z <= 16600000000000.0) {
		tmp = x;
	} else {
		tmp = x * z;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if z <= -5.4e+38:
		tmp = x * z
	elif z <= -1.12e-265:
		tmp = y * t
	elif z <= 16600000000000.0:
		tmp = x
	else:
		tmp = x * z
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (z <= -5.4e+38)
		tmp = Float64(x * z);
	elseif (z <= -1.12e-265)
		tmp = Float64(y * t);
	elseif (z <= 16600000000000.0)
		tmp = x;
	else
		tmp = Float64(x * z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (z <= -5.4e+38)
		tmp = x * z;
	elseif (z <= -1.12e-265)
		tmp = y * t;
	elseif (z <= 16600000000000.0)
		tmp = x;
	else
		tmp = x * z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[z, -5.4e+38], N[(x * z), $MachinePrecision], If[LessEqual[z, -1.12e-265], N[(y * t), $MachinePrecision], If[LessEqual[z, 16600000000000.0], x, N[(x * z), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if z < -5.39999999999999992e38 or 1.66e13 < z

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 55.3%

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

      1. +-commutative 55.3%

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

      2. distribute-rgt1-in 55.3%

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

      3. mul-1-neg 55.3%

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

      4. cancel-sign-sub-inv 55.3%

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

      5. *-commutative 55.3%

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

   4. Simplified 55.3%

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

   5. Taylor expanded in z around inf 47.0%

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

   if -5.39999999999999992e38 < z < -1.12e-265

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 76.6%

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

   3. Taylor expanded in y around inf 45.8%

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

   if -1.12e-265 < z < 1.66e13

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 70.8%

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

   3. Taylor expanded in x around inf 38.3%

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

4. Final simplification 44.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5.4 \cdot 10^{+38}:\\ \;\;\;\;x \cdot z\\ \mathbf{elif}\;z \leq -1.12 \cdot 10^{-265}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;z \leq 16600000000000:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \]

Alternative 10: 54.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -7.1 \cdot 10^{-28} \lor \neg \left(t \leq 9.5 \cdot 10^{-191}\right):\\ \;\;\;\;\left(y - z\right) \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -7.1e-28) (not (<= t 9.5e-191))) (* (- y z) t) (* x z)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -7.1e-28) || !(t <= 9.5e-191)) {
		tmp = (y - 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 ((t <= (-7.1d-28)) .or. (.not. (t <= 9.5d-191))) then
        tmp = (y - 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 ((t <= -7.1e-28) || !(t <= 9.5e-191)) {
		tmp = (y - z) * t;
	} else {
		tmp = x * z;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -7.1e-28) or not (t <= 9.5e-191):
		tmp = (y - z) * t
	else:
		tmp = x * z
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -7.1e-28) || !(t <= 9.5e-191))
		tmp = Float64(Float64(y - z) * t);
	else
		tmp = Float64(x * z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t <= -7.1e-28) || ~((t <= 9.5e-191)))
		tmp = (y - z) * t;
	else
		tmp = x * z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -7.1e-28], N[Not[LessEqual[t, 9.5e-191]], $MachinePrecision]], N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision], N[(x * z), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -7.09999999999999981e-28 or 9.4999999999999996e-191 < t

   1. Initial program 100.0%

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

      1. flip-+ 25.4%

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

      2. div-inv 25.3%

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

      3. pow2 25.3%

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

   3. Applied egg-rr 25.3%

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

   4. Taylor expanded in t around -inf 80.9%

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

   5. Taylor expanded in x around 0 66.5%

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

   if -7.09999999999999981e-28 < t < 9.4999999999999996e-191

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 87.6%

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

      1. +-commutative 87.6%

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

      2. distribute-rgt1-in 87.6%

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

      3. mul-1-neg 87.6%

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

      4. cancel-sign-sub-inv 87.6%

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

      5. *-commutative 87.6%

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

   4. Simplified 87.6%

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

   5. Taylor expanded in z around inf 42.3%

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

4. Final simplification 58.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -7.1 \cdot 10^{-28} \lor \neg \left(t \leq 9.5 \cdot 10^{-191}\right):\\ \;\;\;\;\left(y - z\right) \cdot t\\ \mathbf{else}:\\ \;\;\;\;x \cdot z\\ \end{array} \]

Alternative 11: 61.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= t -1.75e-20) (not (<= t 7.6e-190))) (* (- y z) t) (+ x (* x z))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((t <= -1.75e-20) || !(t <= 7.6e-190)) {
		tmp = (y - z) * t;
	} 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 ((t <= (-1.75d-20)) .or. (.not. (t <= 7.6d-190))) then
        tmp = (y - z) * t
    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 ((t <= -1.75e-20) || !(t <= 7.6e-190)) {
		tmp = (y - z) * t;
	} else {
		tmp = x + (x * z);
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (t <= -1.75e-20) or not (t <= 7.6e-190):
		tmp = (y - z) * t
	else:
		tmp = x + (x * z)
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((t <= -1.75e-20) || !(t <= 7.6e-190))
		tmp = Float64(Float64(y - z) * t);
	else
		tmp = Float64(x + Float64(x * z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((t <= -1.75e-20) || ~((t <= 7.6e-190)))
		tmp = (y - z) * t;
	else
		tmp = x + (x * z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[t, -1.75e-20], N[Not[LessEqual[t, 7.6e-190]], $MachinePrecision]], N[(N[(y - z), $MachinePrecision] * t), $MachinePrecision], N[(x + N[(x * z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -1.75000000000000002e-20 or 7.5999999999999996e-190 < t

   1. Initial program 100.0%

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

      1. flip-+ 24.5%

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

      2. div-inv 24.4%

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

      3. pow2 24.4%

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

   3. Applied egg-rr 24.4%

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

   4. Taylor expanded in t around -inf 80.7%

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

   5. Taylor expanded in x around 0 67.3%

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

   if -1.75000000000000002e-20 < t < 7.5999999999999996e-190

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in x around inf 87.9%

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

      1. +-commutative 87.9%

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

      2. distribute-rgt1-in 87.9%

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

      3. mul-1-neg 87.9%

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

      4. cancel-sign-sub-inv 87.9%

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

      5. *-commutative 87.9%

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

   4. Simplified 87.9%

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

   5. Taylor expanded in y around 0 86.8%

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

      1. +-commutative 86.8%

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

      2. mul-1-neg 86.8%

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

      3. sub-neg 86.8%

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

      4. mul-1-neg 86.8%

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

   7. Simplified 86.8%

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

   8. Taylor expanded in y around 0 63.3%

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

4. Final simplification 65.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -1.75 \cdot 10^{-20} \lor \neg \left(t \leq 7.6 \cdot 10^{-190}\right):\\ \;\;\;\;\left(y - z\right) \cdot t\\ \mathbf{else}:\\ \;\;\;\;x + x \cdot z\\ \end{array} \]

Alternative 12: 36.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -9.5 \cdot 10^{-24}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;y \leq 1.15 \cdot 10^{-99}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (<= y -9.5e-24) (* y t) (if (<= y 1.15e-99) x (* y t))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -9.5e-24) {
		tmp = y * t;
	} else if (y <= 1.15e-99) {
		tmp = x;
	} else {
		tmp = y * t;
	}
	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 (y <= (-9.5d-24)) then
        tmp = y * t
    else if (y <= 1.15d-99) then
        tmp = x
    else
        tmp = y * t
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= -9.5e-24) {
		tmp = y * t;
	} else if (y <= 1.15e-99) {
		tmp = x;
	} else {
		tmp = y * t;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= -9.5e-24:
		tmp = y * t
	elif y <= 1.15e-99:
		tmp = x
	else:
		tmp = y * t
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= -9.5e-24)
		tmp = Float64(y * t);
	elseif (y <= 1.15e-99)
		tmp = x;
	else
		tmp = Float64(y * t);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= -9.5e-24)
		tmp = y * t;
	elseif (y <= 1.15e-99)
		tmp = x;
	else
		tmp = y * t;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, -9.5e-24], N[(y * t), $MachinePrecision], If[LessEqual[y, 1.15e-99], x, N[(y * t), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if y < -9.50000000000000029e-24 or 1.1499999999999999e-99 < y

   1. Initial program 99.9%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 56.3%

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

   3. Taylor expanded in y around inf 40.4%

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

   if -9.50000000000000029e-24 < y < 1.1499999999999999e-99

   1. Initial program 100.0%

      \[x + \left(y - z\right) \cdot \left(t - x\right) \]

   2. Taylor expanded in t around inf 72.9%

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

   3. Taylor expanded in x around inf 36.7%

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

4. Final simplification 38.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -9.5 \cdot 10^{-24}:\\ \;\;\;\;y \cdot t\\ \mathbf{elif}\;y \leq 1.15 \cdot 10^{-99}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;y \cdot t\\ \end{array} \]

Alternative 13: 17.2% 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. Taylor expanded in t around inf 62.9%

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

3. Taylor expanded in x around inf 17.0%

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

4. Final simplification 17.0%

   \[\leadsto x \]

Developer target: 96.3% 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 2023268 
(FPCore (x y z t)
  :name "Data.Metrics.Snapshot:quantile from metrics-0.3.0.2"
  :precision binary64

  :herbie-target
  (+ x (+ (* t (- y z)) (* (- x) (- y z))))

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