Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, B

Percentage Accurate: 97.1% → 99.2%

Time: 23.6s

Alternatives: 8

Speedup: 1.5×

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

Specification

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 97.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.2% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.1%

   \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
2. Add Preprocessing

3. Taylor expanded in z around 0 99.9%

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

   1. associate-*r* 99.9%

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

   2. associate-*r* 99.9%

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

   3. distribute-lft-out 99.9%

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

   4. mul-1-neg 99.9%

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

5. Simplified 99.9%

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

6. Final simplification 99.9%

   \[\leadsto x \cdot e^{y \cdot \left(\log z - t\right) - a \cdot \left(z + b\right)} \]
7. Add Preprocessing

Alternative 2: 93.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -4.3 \cdot 10^{+30} \lor \neg \left(y \leq 0.62\right):\\ \;\;\;\;x \cdot {\left(\frac{z}{e^{t}}\right)}^{y}\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right) - y \cdot t}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -4.3e+30) (not (<= y 0.62)))
   (* x (pow (/ z (exp t)) y))
   (* x (exp (- (* a (- (- b) z)) (* y t))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -4.3e+30) || !(y <= 0.62)) {
		tmp = x * pow((z / exp(t)), y);
	} else {
		tmp = x * exp(((a * (-b - z)) - (y * t)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((y <= (-4.3d+30)) .or. (.not. (y <= 0.62d0))) then
        tmp = x * ((z / exp(t)) ** y)
    else
        tmp = x * exp(((a * (-b - z)) - (y * t)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -4.3e+30) || !(y <= 0.62)) {
		tmp = x * Math.pow((z / Math.exp(t)), y);
	} else {
		tmp = x * Math.exp(((a * (-b - z)) - (y * t)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -4.3e+30) or not (y <= 0.62):
		tmp = x * math.pow((z / math.exp(t)), y)
	else:
		tmp = x * math.exp(((a * (-b - z)) - (y * t)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -4.3e+30) || !(y <= 0.62))
		tmp = Float64(x * (Float64(z / exp(t)) ^ y));
	else
		tmp = Float64(x * exp(Float64(Float64(a * Float64(Float64(-b) - z)) - Float64(y * t))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -4.3e+30) || ~((y <= 0.62)))
		tmp = x * ((z / exp(t)) ^ y);
	else
		tmp = x * exp(((a * (-b - z)) - (y * t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -4.3e+30], N[Not[LessEqual[y, 0.62]], $MachinePrecision]], N[(x * N[Power[N[(z / N[Exp[t], $MachinePrecision]), $MachinePrecision], y], $MachinePrecision]), $MachinePrecision], N[(x * N[Exp[N[(N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision] - N[(y * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -4.3e30 or 0.619999999999999996 < y

   1. Initial program 99.0%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 90.3%

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

      1. *-commutative 90.3%

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

      2. exp-prod 90.3%

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

      3. exp-diff 90.3%

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

      4. rem-exp-log 90.3%

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

   5. Simplified 90.3%

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

   if -4.3e30 < y < 0.619999999999999996

   1. Initial program 94.2%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 99.9%

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

      1. associate-*r* 99.9%

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

      2. associate-*r* 99.9%

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

      3. distribute-lft-out 99.9%

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

      4. mul-1-neg 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in t around inf 98.7%

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

      1. mul-1-neg 98.7%

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

      2. distribute-lft-neg-out 98.7%

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

      3. *-commutative 98.7%

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

   8. Simplified 98.7%

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

4. Final simplification 95.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -4.3 \cdot 10^{+30} \lor \neg \left(y \leq 0.62\right):\\ \;\;\;\;x \cdot {\left(\frac{z}{e^{t}}\right)}^{y}\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right) - y \cdot t}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 70.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot {z}^{y}\\ t_2 := x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{if}\;y \leq -5.4 \cdot 10^{+192}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq -4.3 \cdot 10^{+30}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.42 \cdot 10^{-163}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{elif}\;y \leq 10^{-5} \lor \neg \left(y \leq 4.6 \cdot 10^{+153}\right):\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (pow z y))) (t_2 (* x (exp (* y (- t))))))
   (if (<= y -5.4e+192)
     t_2
     (if (<= y -4.3e+30)
       t_1
       (if (<= y 1.42e-163)
         (* x (exp (* a (- b))))
         (if (or (<= y 1e-5) (not (<= y 4.6e+153))) t_2 t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * pow(z, y);
	double t_2 = x * exp((y * -t));
	double tmp;
	if (y <= -5.4e+192) {
		tmp = t_2;
	} else if (y <= -4.3e+30) {
		tmp = t_1;
	} else if (y <= 1.42e-163) {
		tmp = x * exp((a * -b));
	} else if ((y <= 1e-5) || !(y <= 4.6e+153)) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x * (z ** y)
    t_2 = x * exp((y * -t))
    if (y <= (-5.4d+192)) then
        tmp = t_2
    else if (y <= (-4.3d+30)) then
        tmp = t_1
    else if (y <= 1.42d-163) then
        tmp = x * exp((a * -b))
    else if ((y <= 1d-5) .or. (.not. (y <= 4.6d+153))) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * Math.pow(z, y);
	double t_2 = x * Math.exp((y * -t));
	double tmp;
	if (y <= -5.4e+192) {
		tmp = t_2;
	} else if (y <= -4.3e+30) {
		tmp = t_1;
	} else if (y <= 1.42e-163) {
		tmp = x * Math.exp((a * -b));
	} else if ((y <= 1e-5) || !(y <= 4.6e+153)) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.pow(z, y)
	t_2 = x * math.exp((y * -t))
	tmp = 0
	if y <= -5.4e+192:
		tmp = t_2
	elif y <= -4.3e+30:
		tmp = t_1
	elif y <= 1.42e-163:
		tmp = x * math.exp((a * -b))
	elif (y <= 1e-5) or not (y <= 4.6e+153):
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * (z ^ y))
	t_2 = Float64(x * exp(Float64(y * Float64(-t))))
	tmp = 0.0
	if (y <= -5.4e+192)
		tmp = t_2;
	elseif (y <= -4.3e+30)
		tmp = t_1;
	elseif (y <= 1.42e-163)
		tmp = Float64(x * exp(Float64(a * Float64(-b))));
	elseif ((y <= 1e-5) || !(y <= 4.6e+153))
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * (z ^ y);
	t_2 = x * exp((y * -t));
	tmp = 0.0;
	if (y <= -5.4e+192)
		tmp = t_2;
	elseif (y <= -4.3e+30)
		tmp = t_1;
	elseif (y <= 1.42e-163)
		tmp = x * exp((a * -b));
	elseif ((y <= 1e-5) || ~((y <= 4.6e+153)))
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.4e+192], t$95$2, If[LessEqual[y, -4.3e+30], t$95$1, If[LessEqual[y, 1.42e-163], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, 1e-5], N[Not[LessEqual[y, 4.6e+153]], $MachinePrecision]], t$95$2, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -5.39999999999999979e192 or 1.4200000000000001e-163 < y < 1.00000000000000008e-5 or 4.6000000000000003e153 < y

   1. Initial program 95.5%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 100.0%

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

      1. associate-*r* 100.0%

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

      2. associate-*r* 100.0%

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

      3. distribute-lft-out 100.0%

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

      4. mul-1-neg 100.0%

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

   5. Simplified 100.0%

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

   6. Taylor expanded in t around inf 77.7%

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

      1. mul-1-neg 77.7%

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

   8. Simplified 77.7%

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

   if -5.39999999999999979e192 < y < -4.3e30 or 1.00000000000000008e-5 < y < 4.6000000000000003e153

   1. Initial program 98.2%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 90.6%

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

      1. *-commutative 90.6%

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

      2. exp-prod 90.6%

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

      3. exp-diff 90.6%

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

      4. rem-exp-log 90.6%

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

   5. Simplified 90.6%

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

   6. Taylor expanded in t around 0 79.3%

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

   if -4.3e30 < y < 1.4200000000000001e-163

   1. Initial program 95.7%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 99.9%

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

      1. associate-*r* 99.9%

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

      2. associate-*r* 99.9%

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

      3. distribute-lft-out 99.9%

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

      4. mul-1-neg 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in t around inf 98.2%

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

      1. mul-1-neg 98.2%

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

      2. distribute-lft-neg-out 98.2%

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

      3. *-commutative 98.2%

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

   8. Simplified 98.2%

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

   9. Taylor expanded in b around inf 82.6%

      \[\leadsto x \cdot e^{\color{blue}{-1 \cdot \left(a \cdot b\right)}} \]
   10. Step-by-step derivation

       1. associate-*r* 82.6%

          \[\leadsto x \cdot e^{\color{blue}{\left(-1 \cdot a\right) \cdot b}} \]

       2. mul-1-neg 82.6%

          \[\leadsto x \cdot e^{\color{blue}{\left(-a\right)} \cdot b} \]

   11. Simplified 82.6%

       \[\leadsto x \cdot e^{\color{blue}{\left(-a\right) \cdot b}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 80.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -5.4 \cdot 10^{+192}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{elif}\;y \leq -4.3 \cdot 10^{+30}:\\ \;\;\;\;x \cdot {z}^{y}\\ \mathbf{elif}\;y \leq 1.42 \cdot 10^{-163}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{elif}\;y \leq 10^{-5} \lor \neg \left(y \leq 4.6 \cdot 10^{+153}\right):\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot {z}^{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 70.7% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot {\left(z - z \cdot t\right)}^{y}\\ t_2 := x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{if}\;y \leq -7.2 \cdot 10^{+181}:\\ \;\;\;\;t\_2\\ \mathbf{elif}\;y \leq -1.55 \cdot 10^{+23}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 1.42 \cdot 10^{-163}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{elif}\;y \leq 1.65 \cdot 10^{+63}:\\ \;\;\;\;t\_2\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (pow (- z (* z t)) y))) (t_2 (* x (exp (* y (- t))))))
   (if (<= y -7.2e+181)
     t_2
     (if (<= y -1.55e+23)
       t_1
       (if (<= y 1.42e-163)
         (* x (exp (* a (- b))))
         (if (<= y 1.65e+63) t_2 t_1))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * pow((z - (z * t)), y);
	double t_2 = x * exp((y * -t));
	double tmp;
	if (y <= -7.2e+181) {
		tmp = t_2;
	} else if (y <= -1.55e+23) {
		tmp = t_1;
	} else if (y <= 1.42e-163) {
		tmp = x * exp((a * -b));
	} else if (y <= 1.65e+63) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = x * ((z - (z * t)) ** y)
    t_2 = x * exp((y * -t))
    if (y <= (-7.2d+181)) then
        tmp = t_2
    else if (y <= (-1.55d+23)) then
        tmp = t_1
    else if (y <= 1.42d-163) then
        tmp = x * exp((a * -b))
    else if (y <= 1.65d+63) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * Math.pow((z - (z * t)), y);
	double t_2 = x * Math.exp((y * -t));
	double tmp;
	if (y <= -7.2e+181) {
		tmp = t_2;
	} else if (y <= -1.55e+23) {
		tmp = t_1;
	} else if (y <= 1.42e-163) {
		tmp = x * Math.exp((a * -b));
	} else if (y <= 1.65e+63) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.pow((z - (z * t)), y)
	t_2 = x * math.exp((y * -t))
	tmp = 0
	if y <= -7.2e+181:
		tmp = t_2
	elif y <= -1.55e+23:
		tmp = t_1
	elif y <= 1.42e-163:
		tmp = x * math.exp((a * -b))
	elif y <= 1.65e+63:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * (Float64(z - Float64(z * t)) ^ y))
	t_2 = Float64(x * exp(Float64(y * Float64(-t))))
	tmp = 0.0
	if (y <= -7.2e+181)
		tmp = t_2;
	elseif (y <= -1.55e+23)
		tmp = t_1;
	elseif (y <= 1.42e-163)
		tmp = Float64(x * exp(Float64(a * Float64(-b))));
	elseif (y <= 1.65e+63)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * ((z - (z * t)) ^ y);
	t_2 = x * exp((y * -t));
	tmp = 0.0;
	if (y <= -7.2e+181)
		tmp = t_2;
	elseif (y <= -1.55e+23)
		tmp = t_1;
	elseif (y <= 1.42e-163)
		tmp = x * exp((a * -b));
	elseif (y <= 1.65e+63)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Power[N[(z - N[(z * t), $MachinePrecision]), $MachinePrecision], y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7.2e+181], t$95$2, If[LessEqual[y, -1.55e+23], t$95$1, If[LessEqual[y, 1.42e-163], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.65e+63], t$95$2, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -7.1999999999999997e181 or 1.4200000000000001e-163 < y < 1.6500000000000001e63

   1. Initial program 94.5%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 100.0%

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

      1. associate-*r* 100.0%

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

      2. associate-*r* 100.0%

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

      3. distribute-lft-out 100.0%

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

      4. mul-1-neg 100.0%

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

   5. Simplified 100.0%

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

   6. Taylor expanded in t around inf 79.3%

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

      1. mul-1-neg 79.3%

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

   8. Simplified 79.3%

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

   if -7.1999999999999997e181 < y < -1.54999999999999985e23 or 1.6500000000000001e63 < y

   1. Initial program 98.7%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 90.7%

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

      1. *-commutative 90.7%

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

      2. exp-prod 90.7%

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

      3. exp-diff 90.7%

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

      4. rem-exp-log 90.7%

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

   5. Simplified 90.7%

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

   6. Taylor expanded in t around 0 80.0%

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

      1. associate-*r* 80.0%

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

      2. neg-mul-1 80.0%

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

   8. Simplified 80.0%

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

   if -1.54999999999999985e23 < y < 1.4200000000000001e-163

   1. Initial program 95.5%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 99.9%

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

      1. associate-*r* 99.9%

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

      2. associate-*r* 99.9%

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

      3. distribute-lft-out 99.9%

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

      4. mul-1-neg 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in t around inf 98.2%

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

      1. mul-1-neg 98.2%

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

      2. distribute-lft-neg-out 98.2%

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

      3. *-commutative 98.2%

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

   8. Simplified 98.2%

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

   9. Taylor expanded in b around inf 83.5%

      \[\leadsto x \cdot e^{\color{blue}{-1 \cdot \left(a \cdot b\right)}} \]
   10. Step-by-step derivation

       1. associate-*r* 83.5%

          \[\leadsto x \cdot e^{\color{blue}{\left(-1 \cdot a\right) \cdot b}} \]

       2. mul-1-neg 83.5%

          \[\leadsto x \cdot e^{\color{blue}{\left(-a\right)} \cdot b} \]

   11. Simplified 83.5%

       \[\leadsto x \cdot e^{\color{blue}{\left(-a\right) \cdot b}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 81.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -7.2 \cdot 10^{+181}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{elif}\;y \leq -1.55 \cdot 10^{+23}:\\ \;\;\;\;x \cdot {\left(z - z \cdot t\right)}^{y}\\ \mathbf{elif}\;y \leq 1.42 \cdot 10^{-163}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{elif}\;y \leq 1.65 \cdot 10^{+63}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot {\left(z - z \cdot t\right)}^{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 85.6% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -6.1 \cdot 10^{+181} \lor \neg \left(y \leq -4.4 \cdot 10^{+30}\right) \land y \leq 1.5 \cdot 10^{+66}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right) - y \cdot t}\\ \mathbf{else}:\\ \;\;\;\;x \cdot {\left(z - z \cdot t\right)}^{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= y -6.1e+181) (and (not (<= y -4.4e+30)) (<= y 1.5e+66)))
   (* x (exp (- (* a (- (- b) z)) (* y t))))
   (* x (pow (- z (* z t)) y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -6.1e+181) || (!(y <= -4.4e+30) && (y <= 1.5e+66))) {
		tmp = x * exp(((a * (-b - z)) - (y * t)));
	} else {
		tmp = x * pow((z - (z * t)), y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((y <= (-6.1d+181)) .or. (.not. (y <= (-4.4d+30))) .and. (y <= 1.5d+66)) then
        tmp = x * exp(((a * (-b - z)) - (y * t)))
    else
        tmp = x * ((z - (z * t)) ** y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((y <= -6.1e+181) || (!(y <= -4.4e+30) && (y <= 1.5e+66))) {
		tmp = x * Math.exp(((a * (-b - z)) - (y * t)));
	} else {
		tmp = x * Math.pow((z - (z * t)), y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (y <= -6.1e+181) or (not (y <= -4.4e+30) and (y <= 1.5e+66)):
		tmp = x * math.exp(((a * (-b - z)) - (y * t)))
	else:
		tmp = x * math.pow((z - (z * t)), y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((y <= -6.1e+181) || (!(y <= -4.4e+30) && (y <= 1.5e+66)))
		tmp = Float64(x * exp(Float64(Float64(a * Float64(Float64(-b) - z)) - Float64(y * t))));
	else
		tmp = Float64(x * (Float64(z - Float64(z * t)) ^ y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((y <= -6.1e+181) || (~((y <= -4.4e+30)) && (y <= 1.5e+66)))
		tmp = x * exp(((a * (-b - z)) - (y * t)));
	else
		tmp = x * ((z - (z * t)) ^ y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -6.1e+181], And[N[Not[LessEqual[y, -4.4e+30]], $MachinePrecision], LessEqual[y, 1.5e+66]]], N[(x * N[Exp[N[(N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision] - N[(y * t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(x * N[Power[N[(z - N[(z * t), $MachinePrecision]), $MachinePrecision], y], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -6.10000000000000001e181 or -4.4e30 < y < 1.50000000000000001e66

   1. Initial program 95.2%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 99.9%

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

      1. associate-*r* 99.9%

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

      2. associate-*r* 99.9%

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

      3. distribute-lft-out 99.9%

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

      4. mul-1-neg 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in t around inf 96.8%

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

      1. mul-1-neg 96.8%

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

      2. distribute-lft-neg-out 96.8%

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

      3. *-commutative 96.8%

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

   8. Simplified 96.8%

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

   if -6.10000000000000001e181 < y < -4.4e30 or 1.50000000000000001e66 < y

   1. Initial program 98.6%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 90.0%

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

      1. *-commutative 90.0%

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

      2. exp-prod 90.0%

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

      3. exp-diff 90.0%

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

      4. rem-exp-log 90.0%

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

   5. Simplified 90.0%

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

   6. Taylor expanded in t around 0 80.0%

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

      1. associate-*r* 80.0%

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

      2. neg-mul-1 80.0%

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

   8. Simplified 80.0%

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

4. Final simplification 92.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -6.1 \cdot 10^{+181} \lor \neg \left(y \leq -4.4 \cdot 10^{+30}\right) \land y \leq 1.5 \cdot 10^{+66}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right) - y \cdot t}\\ \mathbf{else}:\\ \;\;\;\;x \cdot {\left(z - z \cdot t\right)}^{y}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 72.1% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2600000000 \lor \neg \left(t \leq 5 \cdot 10^{-36}\right):\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot {z}^{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (or (<= t -2600000000.0) (not (<= t 5e-36)))
   (* x (exp (* y (- t))))
   (* x (pow z y))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((t <= -2600000000.0) || !(t <= 5e-36)) {
		tmp = x * exp((y * -t));
	} else {
		tmp = x * pow(z, y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if ((t <= (-2600000000.0d0)) .or. (.not. (t <= 5d-36))) then
        tmp = x * exp((y * -t))
    else
        tmp = x * (z ** y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if ((t <= -2600000000.0) || !(t <= 5e-36)) {
		tmp = x * Math.exp((y * -t));
	} else {
		tmp = x * Math.pow(z, y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if (t <= -2600000000.0) or not (t <= 5e-36):
		tmp = x * math.exp((y * -t))
	else:
		tmp = x * math.pow(z, y)
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if ((t <= -2600000000.0) || !(t <= 5e-36))
		tmp = Float64(x * exp(Float64(y * Float64(-t))));
	else
		tmp = Float64(x * (z ^ y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if ((t <= -2600000000.0) || ~((t <= 5e-36)))
		tmp = x * exp((y * -t));
	else
		tmp = x * (z ^ y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -2600000000.0], N[Not[LessEqual[t, 5e-36]], $MachinePrecision]], N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < -2.6e9 or 5.00000000000000004e-36 < t

   1. Initial program 96.9%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in z around 0 99.9%

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

      1. associate-*r* 99.9%

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

      2. associate-*r* 99.9%

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

      3. distribute-lft-out 99.9%

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

      4. mul-1-neg 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in t around inf 78.5%

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

      1. mul-1-neg 78.5%

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

   8. Simplified 78.5%

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

   if -2.6e9 < t < 5.00000000000000004e-36

   1. Initial program 95.3%

      \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in a around 0 64.3%

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

      1. *-commutative 64.3%

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

      2. exp-prod 62.7%

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

      3. exp-diff 62.7%

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

      4. rem-exp-log 62.7%

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

   5. Simplified 62.7%

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

   6. Taylor expanded in t around 0 64.3%

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

4. Final simplification 71.7%

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

Alternative 7: 53.2% accurate, 3.0× speedup

Math

\[\begin{array}{l} \\ x \cdot {z}^{y} \end{array} \]

FPCore

(FPCore (x y z t a b) :precision binary64 (* x (pow z y)))

C

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

Fortran

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

Java

public static double code(double x, double y, double z, double t, double a, double b) {
	return x * Math.pow(z, y);
}

Python

def code(x, y, z, t, a, b):
	return x * math.pow(z, y)

Julia

function code(x, y, z, t, a, b)
	return Float64(x * (z ^ y))
end

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 96.1%

   \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
2. Add Preprocessing

3. Taylor expanded in a around 0 71.7%

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

   1. *-commutative 71.7%

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

   2. exp-prod 65.7%

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

   3. exp-diff 65.7%

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

   4. rem-exp-log 65.7%

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

5. Simplified 65.7%

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

6. Taylor expanded in t around 0 49.8%

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

7. Final simplification 49.8%

   \[\leadsto x \cdot {z}^{y} \]
8. Add Preprocessing

Alternative 8: 19.5% accurate, 315.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.1%

   \[x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \]
2. Add Preprocessing

3. Taylor expanded in y around 0 59.6%

   \[\leadsto x \cdot \color{blue}{e^{a \cdot \left(\log \left(1 - z\right) - b\right)}} \]
4. Step-by-step derivation

   1. *-commutative 59.6%

      \[\leadsto x \cdot e^{\color{blue}{\left(\log \left(1 - z\right) - b\right) \cdot a}} \]

   2. exp-prod 52.1%

      \[\leadsto x \cdot \color{blue}{{\left(e^{\log \left(1 - z\right) - b}\right)}^{a}} \]

   3. exp-diff 52.1%

      \[\leadsto x \cdot {\color{blue}{\left(\frac{e^{\log \left(1 - z\right)}}{e^{b}}\right)}}^{a} \]

   4. rem-exp-log 52.1%

      \[\leadsto x \cdot {\left(\frac{\color{blue}{1 - z}}{e^{b}}\right)}^{a} \]

5. Simplified 52.1%

   \[\leadsto x \cdot \color{blue}{{\left(\frac{1 - z}{e^{b}}\right)}^{a}} \]

6. Taylor expanded in a around 0 22.3%

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

7. Final simplification 22.3%

   \[\leadsto x \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2024082 
(FPCore (x y z t a b)
  :name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, B"
  :precision binary64
  (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))