Numeric.SpecFunctions:incompleteGamma from math-functions-0.1.5.2, A

Percentage Accurate: 99.9% → 99.9%

Time: 17.3s

Alternatives: 13

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(x, \log y, \log t - \left(y + z\right)\right) \end{array} \]

FPCore

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

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

2. Taylor expanded in x around 0 99.8%

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

   1. +-commutative 99.8%

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

   2. +-commutative 99.8%

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

   3. associate-+r- 99.8%

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

   4. associate--l- 99.8%

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

   5. fma-def 99.8%

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

   6. associate--l- 99.8%

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

   7. +-commutative 99.8%

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

4. Simplified 99.8%

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

5. Final simplification 99.8%

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

Alternative 2: 99.9% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(x, \log y, \log t - z\right) - y \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (- (fma x (log y) (- (log t) z)) y))

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

   1. associate-+l- 99.8%

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

   2. associate--l- 99.8%

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

   3. +-commutative 99.8%

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

   4. associate--r+ 99.8%

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

   5. fma-neg 99.8%

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

   6. neg-sub0 99.8%

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

   7. associate-+l- 99.8%

      \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

   8. neg-sub0 99.8%

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

   9. +-commutative 99.8%

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

   10. unsub-neg 99.8%

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

3. Simplified 99.8%

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

4. Final simplification 99.8%

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

Alternative 3: 89.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -5.5 \cdot 10^{+36} \lor \neg \left(x \leq 2.7 \cdot 10^{+62}\right):\\ \;\;\;\;\left(\log t + x \cdot \log y\right) - y\\ \mathbf{else}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= x -5.5e+36) (not (<= x 2.7e+62)))
   (- (+ (log t) (* x (log y))) y)
   (- (- (log t) z) y)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((x <= -5.5e+36) || !(x <= 2.7e+62)) {
		tmp = (log(t) + (x * log(y))) - y;
	} else {
		tmp = (log(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 <= (-5.5d+36)) .or. (.not. (x <= 2.7d+62))) then
        tmp = (log(t) + (x * log(y))) - y
    else
        tmp = (log(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 <= -5.5e+36) || !(x <= 2.7e+62)) {
		tmp = (Math.log(t) + (x * Math.log(y))) - y;
	} else {
		tmp = (Math.log(t) - z) - y;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if (x <= -5.5e+36) or not (x <= 2.7e+62):
		tmp = (math.log(t) + (x * math.log(y))) - y
	else:
		tmp = (math.log(t) - z) - y
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((x <= -5.5e+36) || !(x <= 2.7e+62))
		tmp = Float64(Float64(log(t) + Float64(x * log(y))) - y);
	else
		tmp = Float64(Float64(log(t) - z) - y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((x <= -5.5e+36) || ~((x <= 2.7e+62)))
		tmp = (log(t) + (x * log(y))) - y;
	else
		tmp = (log(t) - z) - y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[Or[LessEqual[x, -5.5e+36], N[Not[LessEqual[x, 2.7e+62]], $MachinePrecision]], N[(N[(N[Log[t], $MachinePrecision] + N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision], N[(N[(N[Log[t], $MachinePrecision] - z), $MachinePrecision] - y), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < -5.5000000000000002e36 or 2.7e62 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in z around 0 82.1%

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

   if -5.5000000000000002e36 < x < 2.7e62

   1. Initial program 100.0%

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

      1. associate-+l- 100.0%

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

      2. associate--l- 100.0%

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

      3. +-commutative 100.0%

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

      4. associate--r+ 100.0%

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

      5. fma-neg 100.0%

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

      6. neg-sub0 100.0%

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

      7. associate-+l- 100.0%

         \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

      8. neg-sub0 100.0%

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

      9. +-commutative 100.0%

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

      10. unsub-neg 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in x around 0 97.7%

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

4. Final simplification 90.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -5.5 \cdot 10^{+36} \lor \neg \left(x \leq 2.7 \cdot 10^{+62}\right):\\ \;\;\;\;\left(\log t + x \cdot \log y\right) - y\\ \mathbf{else}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \end{array} \]

Alternative 4: 89.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \log t + x \cdot \log y\\ \mathbf{if}\;x \leq -3.9 \cdot 10^{+36}:\\ \;\;\;\;t_1 - y\\ \mathbf{elif}\;x \leq 1.35 \cdot 10^{+42}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \mathbf{else}:\\ \;\;\;\;t_1 - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (+ (log t) (* x (log y)))))
   (if (<= x -3.9e+36)
     (- t_1 y)
     (if (<= x 1.35e+42) (- (- (log t) z) y) (- t_1 z)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = log(t) + (x * log(y));
	double tmp;
	if (x <= -3.9e+36) {
		tmp = t_1 - y;
	} else if (x <= 1.35e+42) {
		tmp = (log(t) - z) - y;
	} else {
		tmp = t_1 - 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) :: t_1
    real(8) :: tmp
    t_1 = log(t) + (x * log(y))
    if (x <= (-3.9d+36)) then
        tmp = t_1 - y
    else if (x <= 1.35d+42) then
        tmp = (log(t) - z) - y
    else
        tmp = t_1 - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double t_1 = Math.log(t) + (x * Math.log(y));
	double tmp;
	if (x <= -3.9e+36) {
		tmp = t_1 - y;
	} else if (x <= 1.35e+42) {
		tmp = (Math.log(t) - z) - y;
	} else {
		tmp = t_1 - z;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = math.log(t) + (x * math.log(y))
	tmp = 0
	if x <= -3.9e+36:
		tmp = t_1 - y
	elif x <= 1.35e+42:
		tmp = (math.log(t) - z) - y
	else:
		tmp = t_1 - z
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(log(t) + Float64(x * log(y)))
	tmp = 0.0
	if (x <= -3.9e+36)
		tmp = Float64(t_1 - y);
	elseif (x <= 1.35e+42)
		tmp = Float64(Float64(log(t) - z) - y);
	else
		tmp = Float64(t_1 - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = log(t) + (x * log(y));
	tmp = 0.0;
	if (x <= -3.9e+36)
		tmp = t_1 - y;
	elseif (x <= 1.35e+42)
		tmp = (log(t) - z) - y;
	else
		tmp = t_1 - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Log[t], $MachinePrecision] + N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.9e+36], N[(t$95$1 - y), $MachinePrecision], If[LessEqual[x, 1.35e+42], N[(N[(N[Log[t], $MachinePrecision] - z), $MachinePrecision] - y), $MachinePrecision], N[(t$95$1 - z), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.90000000000000021e36

   1. Initial program 99.7%

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

   2. Taylor expanded in z around 0 80.7%

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

   if -3.90000000000000021e36 < x < 1.35e42

   1. Initial program 100.0%

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

      1. associate-+l- 100.0%

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

      2. associate--l- 100.0%

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

      3. +-commutative 100.0%

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

      4. associate--r+ 100.0%

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

      5. fma-neg 100.0%

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

      6. neg-sub0 100.0%

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

      7. associate-+l- 100.0%

         \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

      8. neg-sub0 100.0%

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

      9. +-commutative 100.0%

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

      10. unsub-neg 100.0%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in x around 0 98.0%

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

   if 1.35e42 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in y around 0 91.5%

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

4. Final simplification 92.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.9 \cdot 10^{+36}:\\ \;\;\;\;\left(\log t + x \cdot \log y\right) - y\\ \mathbf{elif}\;x \leq 1.35 \cdot 10^{+42}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \mathbf{else}:\\ \;\;\;\;\left(\log t + x \cdot \log y\right) - z\\ \end{array} \]

Alternative 5: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t) {
	return log(t) + (((x * log(y)) - 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 = log(t) + (((x * log(y)) - y) - z)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

2. Final simplification 99.8%

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

Alternative 6: 47.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \log y\\ \mathbf{if}\;x \leq -3.7 \cdot 10^{+151}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq -7 \cdot 10^{+106}:\\ \;\;\;\;-y\\ \mathbf{elif}\;x \leq -9.2 \cdot 10^{+30}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.25 \cdot 10^{-23}:\\ \;\;\;\;-y\\ \mathbf{elif}\;x \leq 6.5 \cdot 10^{+62}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* x (log y))))
   (if (<= x -3.7e+151)
     t_1
     (if (<= x -7e+106)
       (- y)
       (if (<= x -9.2e+30)
         t_1
         (if (<= x 2.25e-23) (- y) (if (<= x 6.5e+62) (- z) t_1)))))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * log(y);
	double tmp;
	if (x <= -3.7e+151) {
		tmp = t_1;
	} else if (x <= -7e+106) {
		tmp = -y;
	} else if (x <= -9.2e+30) {
		tmp = t_1;
	} else if (x <= 2.25e-23) {
		tmp = -y;
	} else if (x <= 6.5e+62) {
		tmp = -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 * log(y)
    if (x <= (-3.7d+151)) then
        tmp = t_1
    else if (x <= (-7d+106)) then
        tmp = -y
    else if (x <= (-9.2d+30)) then
        tmp = t_1
    else if (x <= 2.25d-23) then
        tmp = -y
    else if (x <= 6.5d+62) then
        tmp = -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 * Math.log(y);
	double tmp;
	if (x <= -3.7e+151) {
		tmp = t_1;
	} else if (x <= -7e+106) {
		tmp = -y;
	} else if (x <= -9.2e+30) {
		tmp = t_1;
	} else if (x <= 2.25e-23) {
		tmp = -y;
	} else if (x <= 6.5e+62) {
		tmp = -z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x * math.log(y)
	tmp = 0
	if x <= -3.7e+151:
		tmp = t_1
	elif x <= -7e+106:
		tmp = -y
	elif x <= -9.2e+30:
		tmp = t_1
	elif x <= 2.25e-23:
		tmp = -y
	elif x <= 6.5e+62:
		tmp = -z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x * log(y))
	tmp = 0.0
	if (x <= -3.7e+151)
		tmp = t_1;
	elseif (x <= -7e+106)
		tmp = Float64(-y);
	elseif (x <= -9.2e+30)
		tmp = t_1;
	elseif (x <= 2.25e-23)
		tmp = Float64(-y);
	elseif (x <= 6.5e+62)
		tmp = Float64(-z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x * log(y);
	tmp = 0.0;
	if (x <= -3.7e+151)
		tmp = t_1;
	elseif (x <= -7e+106)
		tmp = -y;
	elseif (x <= -9.2e+30)
		tmp = t_1;
	elseif (x <= 2.25e-23)
		tmp = -y;
	elseif (x <= 6.5e+62)
		tmp = -z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.7e+151], t$95$1, If[LessEqual[x, -7e+106], (-y), If[LessEqual[x, -9.2e+30], t$95$1, If[LessEqual[x, 2.25e-23], (-y), If[LessEqual[x, 6.5e+62], (-z), t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.6999999999999997e151 or -6.99999999999999962e106 < x < -9.2e30 or 6.5000000000000003e62 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in x around 0 99.6%

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

      1. +-commutative 99.6%

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

      2. +-commutative 99.6%

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

      3. associate-+r- 99.6%

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

      4. associate--l- 99.6%

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

      5. fma-def 99.6%

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

      6. associate--l- 99.6%

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

      7. +-commutative 99.6%

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

   4. Simplified 99.6%

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

   5. Taylor expanded in x around inf 67.9%

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

   if -3.6999999999999997e151 < x < -6.99999999999999962e106 or -9.2e30 < x < 2.24999999999999987e-23

   1. Initial program 100.0%

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

   2. Taylor expanded in x around 0 100.0%

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

      1. +-commutative 100.0%

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

      2. +-commutative 100.0%

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

      3. associate-+r- 100.0%

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

      4. associate--l- 100.0%

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

      5. fma-def 100.0%

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

      6. associate--l- 100.0%

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

      7. +-commutative 100.0%

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

   4. Simplified 100.0%

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

   5. Taylor expanded in y around inf 50.7%

      \[\leadsto \color{blue}{-1 \cdot y} \]
   6. Step-by-step derivation

      1. neg-mul-1 50.7%

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

   7. Simplified 50.7%

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

   if 2.24999999999999987e-23 < x < 6.5000000000000003e62

   1. Initial program 100.0%

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

   2. Taylor expanded in z around inf 72.7%

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

      1. neg-mul-1 72.7%

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

   4. Simplified 72.7%

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

4. Final simplification 58.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.7 \cdot 10^{+151}:\\ \;\;\;\;x \cdot \log y\\ \mathbf{elif}\;x \leq -7 \cdot 10^{+106}:\\ \;\;\;\;-y\\ \mathbf{elif}\;x \leq -9.2 \cdot 10^{+30}:\\ \;\;\;\;x \cdot \log y\\ \mathbf{elif}\;x \leq 2.25 \cdot 10^{-23}:\\ \;\;\;\;-y\\ \mathbf{elif}\;x \leq 6.5 \cdot 10^{+62}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;x \cdot \log y\\ \end{array} \]

Alternative 7: 58.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \log y\\ \mathbf{if}\;x \leq -3.7 \cdot 10^{+151}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-22}:\\ \;\;\;\;\log t - y\\ \mathbf{elif}\;x \leq 9.5 \cdot 10^{+63}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* x (log y))))
   (if (<= x -3.7e+151)
     t_1
     (if (<= x 1.5e-22) (- (log t) y) (if (<= x 9.5e+63) (- z) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * log(y);
	double tmp;
	if (x <= -3.7e+151) {
		tmp = t_1;
	} else if (x <= 1.5e-22) {
		tmp = log(t) - y;
	} else if (x <= 9.5e+63) {
		tmp = -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 * log(y)
    if (x <= (-3.7d+151)) then
        tmp = t_1
    else if (x <= 1.5d-22) then
        tmp = log(t) - y
    else if (x <= 9.5d+63) then
        tmp = -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 * Math.log(y);
	double tmp;
	if (x <= -3.7e+151) {
		tmp = t_1;
	} else if (x <= 1.5e-22) {
		tmp = Math.log(t) - y;
	} else if (x <= 9.5e+63) {
		tmp = -z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x * math.log(y)
	tmp = 0
	if x <= -3.7e+151:
		tmp = t_1
	elif x <= 1.5e-22:
		tmp = math.log(t) - y
	elif x <= 9.5e+63:
		tmp = -z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x * log(y))
	tmp = 0.0
	if (x <= -3.7e+151)
		tmp = t_1;
	elseif (x <= 1.5e-22)
		tmp = Float64(log(t) - y);
	elseif (x <= 9.5e+63)
		tmp = Float64(-z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x * log(y);
	tmp = 0.0;
	if (x <= -3.7e+151)
		tmp = t_1;
	elseif (x <= 1.5e-22)
		tmp = log(t) - y;
	elseif (x <= 9.5e+63)
		tmp = -z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.7e+151], t$95$1, If[LessEqual[x, 1.5e-22], N[(N[Log[t], $MachinePrecision] - y), $MachinePrecision], If[LessEqual[x, 9.5e+63], (-z), t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.6999999999999997e151 or 9.5000000000000003e63 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in x around 0 99.6%

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

      1. +-commutative 99.6%

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

      2. +-commutative 99.6%

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

      3. associate-+r- 99.6%

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

      4. associate--l- 99.6%

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

      5. fma-def 99.6%

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

      6. associate--l- 99.6%

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

      7. +-commutative 99.6%

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

   4. Simplified 99.6%

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

   5. Taylor expanded in x around inf 72.3%

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

   if -3.6999999999999997e151 < x < 1.5e-22

   1. Initial program 99.9%

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

   2. Taylor expanded in x around 0 99.9%

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

      1. +-commutative 99.9%

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

      2. +-commutative 99.9%

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

      3. associate-+r- 99.9%

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

      4. associate--l- 99.9%

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

      5. fma-def 99.9%

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

      6. associate--l- 99.9%

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

      7. +-commutative 99.9%

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

   4. Simplified 99.9%

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

   5. Taylor expanded in z around 0 74.9%

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

   6. Taylor expanded in x around 0 69.0%

      \[\leadsto \color{blue}{\log t - y} \]

   if 1.5e-22 < x < 9.5000000000000003e63

   1. Initial program 100.0%

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

   2. Taylor expanded in z around inf 72.7%

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

      1. neg-mul-1 72.7%

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

   4. Simplified 72.7%

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

4. Final simplification 70.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.7 \cdot 10^{+151}:\\ \;\;\;\;x \cdot \log y\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-22}:\\ \;\;\;\;\log t - y\\ \mathbf{elif}\;x \leq 9.5 \cdot 10^{+63}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;x \cdot \log y\\ \end{array} \]

Alternative 8: 58.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot \log y\\ \mathbf{if}\;x \leq -4.9 \cdot 10^{+151}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;x \leq 2.35 \cdot 10^{-26}:\\ \;\;\;\;\log t - y\\ \mathbf{elif}\;x \leq 9.2 \cdot 10^{+63}:\\ \;\;\;\;\log t - z\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (let* ((t_1 (* x (log y))))
   (if (<= x -4.9e+151)
     t_1
     (if (<= x 2.35e-26)
       (- (log t) y)
       (if (<= x 9.2e+63) (- (log t) z) t_1)))))

C

double code(double x, double y, double z, double t) {
	double t_1 = x * log(y);
	double tmp;
	if (x <= -4.9e+151) {
		tmp = t_1;
	} else if (x <= 2.35e-26) {
		tmp = log(t) - y;
	} else if (x <= 9.2e+63) {
		tmp = log(t) - 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 * log(y)
    if (x <= (-4.9d+151)) then
        tmp = t_1
    else if (x <= 2.35d-26) then
        tmp = log(t) - y
    else if (x <= 9.2d+63) then
        tmp = log(t) - 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 * Math.log(y);
	double tmp;
	if (x <= -4.9e+151) {
		tmp = t_1;
	} else if (x <= 2.35e-26) {
		tmp = Math.log(t) - y;
	} else if (x <= 9.2e+63) {
		tmp = Math.log(t) - z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	t_1 = x * math.log(y)
	tmp = 0
	if x <= -4.9e+151:
		tmp = t_1
	elif x <= 2.35e-26:
		tmp = math.log(t) - y
	elif x <= 9.2e+63:
		tmp = math.log(t) - z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t)
	t_1 = Float64(x * log(y))
	tmp = 0.0
	if (x <= -4.9e+151)
		tmp = t_1;
	elseif (x <= 2.35e-26)
		tmp = Float64(log(t) - y);
	elseif (x <= 9.2e+63)
		tmp = Float64(log(t) - z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	t_1 = x * log(y);
	tmp = 0.0;
	if (x <= -4.9e+151)
		tmp = t_1;
	elseif (x <= 2.35e-26)
		tmp = log(t) - y;
	elseif (x <= 9.2e+63)
		tmp = log(t) - z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.9e+151], t$95$1, If[LessEqual[x, 2.35e-26], N[(N[Log[t], $MachinePrecision] - y), $MachinePrecision], If[LessEqual[x, 9.2e+63], N[(N[Log[t], $MachinePrecision] - z), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if x < -4.8999999999999999e151 or 9.19999999999999973e63 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in x around 0 99.6%

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

      1. +-commutative 99.6%

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

      2. +-commutative 99.6%

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

      3. associate-+r- 99.6%

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

      4. associate--l- 99.6%

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

      5. fma-def 99.6%

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

      6. associate--l- 99.6%

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

      7. +-commutative 99.6%

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

   4. Simplified 99.6%

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

   5. Taylor expanded in x around inf 72.3%

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

   if -4.8999999999999999e151 < x < 2.34999999999999995e-26

   1. Initial program 99.9%

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

   2. Taylor expanded in x around 0 99.9%

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

      1. +-commutative 99.9%

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

      2. +-commutative 99.9%

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

      3. associate-+r- 99.9%

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

      4. associate--l- 99.9%

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

      5. fma-def 99.9%

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

      6. associate--l- 99.9%

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

      7. +-commutative 99.9%

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

   4. Simplified 99.9%

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

   5. Taylor expanded in z around 0 74.9%

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

   6. Taylor expanded in x around 0 69.0%

      \[\leadsto \color{blue}{\log t - y} \]

   if 2.34999999999999995e-26 < x < 9.19999999999999973e63

   1. Initial program 100.0%

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

   2. Taylor expanded in y around 0 89.0%

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

   3. Taylor expanded in x around 0 73.7%

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

4. Final simplification 70.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -4.9 \cdot 10^{+151}:\\ \;\;\;\;x \cdot \log y\\ \mathbf{elif}\;x \leq 2.35 \cdot 10^{-26}:\\ \;\;\;\;\log t - y\\ \mathbf{elif}\;x \leq 9.2 \cdot 10^{+63}:\\ \;\;\;\;\log t - z\\ \mathbf{else}:\\ \;\;\;\;x \cdot \log y\\ \end{array} \]

Alternative 9: 83.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1 \cdot 10^{+154} \lor \neg \left(x \leq 8.5 \cdot 10^{+69}\right):\\ \;\;\;\;x \cdot \log y\\ \mathbf{else}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t)
 :precision binary64
 (if (or (<= x -1e+154) (not (<= x 8.5e+69)))
   (* x (log y))
   (- (- (log t) z) y)))

C

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

Python

def code(x, y, z, t):
	tmp = 0
	if (x <= -1e+154) or not (x <= 8.5e+69):
		tmp = x * math.log(y)
	else:
		tmp = (math.log(t) - z) - y
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if ((x <= -1e+154) || !(x <= 8.5e+69))
		tmp = Float64(x * log(y));
	else
		tmp = Float64(Float64(log(t) - z) - y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if ((x <= -1e+154) || ~((x <= 8.5e+69)))
		tmp = x * log(y);
	else
		tmp = (log(t) - z) - y;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if x < -1.00000000000000004e154 or 8.5000000000000002e69 < x

   1. Initial program 99.6%

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

   2. Taylor expanded in x around 0 99.6%

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

      1. +-commutative 99.6%

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

      2. +-commutative 99.6%

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

      3. associate-+r- 99.6%

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

      4. associate--l- 99.6%

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

      5. fma-def 99.6%

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

      6. associate--l- 99.6%

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

      7. +-commutative 99.6%

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

   4. Simplified 99.6%

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

   5. Taylor expanded in x around inf 73.1%

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

   if -1.00000000000000004e154 < x < 8.5000000000000002e69

   1. Initial program 99.9%

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

      1. associate-+l- 99.9%

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

      2. associate--l- 99.9%

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

      3. +-commutative 99.9%

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

      4. associate--r+ 99.9%

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

      5. fma-neg 99.9%

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

      6. neg-sub0 99.9%

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

      7. associate-+l- 99.9%

         \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

      8. neg-sub0 99.9%

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

      9. +-commutative 99.9%

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

      10. unsub-neg 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in x around 0 93.6%

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

4. Final simplification 86.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1 \cdot 10^{+154} \lor \neg \left(x \leq 8.5 \cdot 10^{+69}\right):\\ \;\;\;\;x \cdot \log y\\ \mathbf{else}:\\ \;\;\;\;\left(\log t - z\right) - y\\ \end{array} \]

Alternative 10: 49.6% accurate, 51.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 4.3 \cdot 10^{+39}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;-y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t) :precision binary64 (if (<= y 4.3e+39) (- z) (- y)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 4.3e+39) {
		tmp = -z;
	} else {
		tmp = -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 (y <= 4.3d+39) then
        tmp = -z
    else
        tmp = -y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t) {
	double tmp;
	if (y <= 4.3e+39) {
		tmp = -z;
	} else {
		tmp = -y;
	}
	return tmp;
}

Python

def code(x, y, z, t):
	tmp = 0
	if y <= 4.3e+39:
		tmp = -z
	else:
		tmp = -y
	return tmp

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (y <= 4.3e+39)
		tmp = Float64(-z);
	else
		tmp = Float64(-y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t)
	tmp = 0.0;
	if (y <= 4.3e+39)
		tmp = -z;
	else
		tmp = -y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[y, 4.3e+39], (-z), (-y)]

Derivation

1. Split input into 2 regimes

2. if y < 4.3e39

   1. Initial program 99.8%

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

   2. Taylor expanded in z around inf 35.4%

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

      1. neg-mul-1 35.4%

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

   4. Simplified 35.4%

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

   if 4.3e39 < y

   1. Initial program 99.9%

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

   2. Taylor expanded in x around 0 99.9%

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

      1. +-commutative 99.9%

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

      2. +-commutative 99.9%

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

      3. associate-+r- 99.9%

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

      4. associate--l- 99.9%

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

      5. fma-def 99.9%

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

      6. associate--l- 99.9%

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

      7. +-commutative 99.9%

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

   4. Simplified 99.9%

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

   5. Taylor expanded in y around inf 64.4%

      \[\leadsto \color{blue}{-1 \cdot y} \]
   6. Step-by-step derivation

      1. neg-mul-1 64.4%

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

   7. Simplified 64.4%

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

4. Final simplification 49.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 4.3 \cdot 10^{+39}:\\ \;\;\;\;-z\\ \mathbf{else}:\\ \;\;\;\;-y\\ \end{array} \]

Alternative 11: 30.1% accurate, 104.5× speedup

Math

\[\begin{array}{l} \\ -y \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := (-y)

Derivation

1. Initial program 99.8%

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

2. Taylor expanded in x around 0 99.8%

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

   1. +-commutative 99.8%

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

   2. +-commutative 99.8%

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

   3. associate-+r- 99.8%

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

   4. associate--l- 99.8%

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

   5. fma-def 99.8%

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

   6. associate--l- 99.8%

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

   7. +-commutative 99.8%

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

4. Simplified 99.8%

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

5. Taylor expanded in y around inf 34.5%

   \[\leadsto \color{blue}{-1 \cdot y} \]
6. Step-by-step derivation

   1. neg-mul-1 34.5%

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

7. Simplified 34.5%

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

8. Final simplification 34.5%

   \[\leadsto -y \]

Alternative 12: 2.2% accurate, 209.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

   1. associate-+l- 99.8%

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

   2. associate--l- 99.8%

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

   3. +-commutative 99.8%

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

   4. associate--r+ 99.8%

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

   5. fma-neg 99.8%

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

   6. neg-sub0 99.8%

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

   7. associate-+l- 99.8%

      \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

   8. neg-sub0 99.8%

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

   9. +-commutative 99.8%

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

   10. unsub-neg 99.8%

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

3. Simplified 99.8%

   \[\leadsto \color{blue}{\mathsf{fma}\left(x, \log y, \log t - z\right) - y} \]
4. Step-by-step derivation

   1. flip-- 40.7%

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

   2. clear-num 40.7%

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

   3. +-commutative 40.7%

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

   4. difference-of-squares 41.7%

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

   5. add-sqr-sqrt 41.7%

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

   6. sqrt-unprod 41.5%

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

   7. sqr-neg 41.5%

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

   8. sqrt-unprod 0.0%

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

   9. add-sqr-sqrt 32.4%

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

   10. sub-neg 32.4%

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

   11. pow2 32.4%

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

5. Applied egg-rr 32.4%

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

6. Taylor expanded in y around inf 2.1%

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

7. Final simplification 2.1%

   \[\leadsto y \]

Alternative 13: 2.2% accurate, 209.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z, double t) {
	return 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 = z
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

   1. associate-+l- 99.8%

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

   2. associate--l- 99.8%

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

   3. +-commutative 99.8%

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

   4. associate--r+ 99.8%

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

   5. fma-neg 99.8%

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

   6. neg-sub0 99.8%

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

   7. associate-+l- 99.8%

      \[\leadsto \mathsf{fma}\left(x, \log y, \color{blue}{\left(0 - z\right) + \log t}\right) - y \]

   8. neg-sub0 99.8%

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

   9. +-commutative 99.8%

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

   10. unsub-neg 99.8%

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

3. Simplified 99.8%

   \[\leadsto \color{blue}{\mathsf{fma}\left(x, \log y, \log t - z\right) - y} \]
4. Step-by-step derivation

   1. flip-- 40.7%

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

   2. clear-num 40.7%

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

   3. +-commutative 40.7%

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

   4. difference-of-squares 41.7%

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

   5. add-sqr-sqrt 41.7%

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

   6. sqrt-unprod 41.5%

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

   7. sqr-neg 41.5%

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

   8. sqrt-unprod 0.0%

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

   9. add-sqr-sqrt 32.4%

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

   10. sub-neg 32.4%

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

   11. pow2 32.4%

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

5. Applied egg-rr 32.4%

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

6. Taylor expanded in z around inf 25.3%

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

   1. add-sqr-sqrt 15.6%

      \[\leadsto \color{blue}{\sqrt{\frac{1}{\frac{-1}{z}}} \cdot \sqrt{\frac{1}{\frac{-1}{z}}}} \]

   2. sqrt-unprod 6.4%

      \[\leadsto \color{blue}{\sqrt{\frac{1}{\frac{-1}{z}} \cdot \frac{1}{\frac{-1}{z}}}} \]

   3. associate-/r/ 6.4%

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

   4. metadata-eval 6.4%

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

   5. associate-/r/ 6.4%

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

   6. metadata-eval 6.4%

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

   7. swap-sqr 6.4%

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

   8. metadata-eval 6.4%

      \[\leadsto \sqrt{\color{blue}{1} \cdot \left(z \cdot z\right)} \]

   9. *-un-lft-identity 6.4%

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

   10. sqrt-unprod 0.6%

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

   11. add-sqr-sqrt 2.1%

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

   12. expm1-log1p-u 1.6%

       \[\leadsto \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(z\right)\right)} \]

   13. expm1-udef 1.5%

       \[\leadsto \color{blue}{e^{\mathsf{log1p}\left(z\right)} - 1} \]

8. Applied egg-rr 1.5%

   \[\leadsto \color{blue}{e^{\mathsf{log1p}\left(z\right)} - 1} \]
9. Step-by-step derivation

   1. expm1-def 1.6%

      \[\leadsto \color{blue}{\mathsf{expm1}\left(\mathsf{log1p}\left(z\right)\right)} \]

   2. expm1-log1p 2.1%

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

10. Simplified 2.1%

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

11. Final simplification 2.1%

    \[\leadsto z \]

Reproduce

herbie shell --seed 2023279 
(FPCore (x y z t)
  :name "Numeric.SpecFunctions:incompleteGamma from math-functions-0.1.5.2, A"
  :precision binary64
  (+ (- (- (* x (log y)) y) z) (log t)))