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

Percentage Accurate: 96.3% → 96.3%

Time: 15.3s

Alternatives: 15

Speedup: 1.0×

• 41.7% 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: 96.3% 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: 96.3% 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]

Derivation

1. Initial program 97.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. Add Preprocessing

Alternative 2: 60.0% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\ \mathbf{if}\;t\_1 \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{elif}\;t\_1 \leq 10^{-12}:\\ \;\;\;\;x \cdot e^{z \cdot \left(-a\right)}\\ \mathbf{else}:\\ \;\;\;\;z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + z \cdot \left(-0.5 \cdot \left(z \cdot \left(x \cdot a\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
   (if (<= t_1 -200000.0)
     (* (* a -0.5) (* x (* z z)))
     (if (<= t_1 1e-12)
       (* x (exp (* z (- a))))
       (+
        (* z (fma a (- x) (/ (fma (* a b) (- x) x) z)))
        (* z (* -0.5 (* z (* x a)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
	double tmp;
	if (t_1 <= -200000.0) {
		tmp = (a * -0.5) * (x * (z * z));
	} else if (t_1 <= 1e-12) {
		tmp = x * exp((z * -a));
	} else {
		tmp = (z * fma(a, -x, (fma((a * b), -x, x) / z))) + (z * (-0.5 * (z * (x * a))));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))
	tmp = 0.0
	if (t_1 <= -200000.0)
		tmp = Float64(Float64(a * -0.5) * Float64(x * Float64(z * z)));
	elseif (t_1 <= 1e-12)
		tmp = Float64(x * exp(Float64(z * Float64(-a))));
	else
		tmp = Float64(Float64(z * fma(a, Float64(-x), Float64(fma(Float64(a * b), Float64(-x), x) / z))) + Float64(z * Float64(-0.5 * Float64(z * Float64(x * a)))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = 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]}, If[LessEqual[t$95$1, -200000.0], N[(N[(a * -0.5), $MachinePrecision] * N[(x * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e-12], N[(x * N[Exp[N[(z * (-a)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(z * N[(a * (-x) + N[(N[(N[(a * b), $MachinePrecision] * (-x) + x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(-0.5 * N[(z * N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -2e5

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 58.6%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.8%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 3.7%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto \frac{-1}{2} \cdot \left(a \cdot \left(x \cdot \color{blue}{{z}^{2}}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 65.1%

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

   if -2e5 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 9.9999999999999998e-13

   1. Initial program 94.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

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. sub-neg N/A

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

      4. lower-log1p.f64 N/A

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

      5. lower-neg.f64 98.7

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

   5. Applied rewrites 98.7%

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

   6. Taylor expanded in z around 0

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

   8. Applied rewrites 98.7%

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

   9. Taylor expanded in b around 0

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

   11. Applied rewrites 96.7%

       \[\leadsto x \cdot e^{-a \cdot z} \]

   if 9.9999999999999998e-13 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 68.4%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 24.1%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 19.4%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto z \cdot \left(-1 \cdot \left(a \cdot x\right) + \left(-1 \cdot \frac{a \cdot \left(b \cdot x\right)}{z} + \frac{x}{z}\right)\right) + \left(\frac{-1}{2} \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot z \]
   13. Step-by-step derivation

   14. Applied rewrites 39.9%

       \[\leadsto z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot z \]
3. Recombined 3 regimes into one program.

4. Final simplification 58.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{elif}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq 10^{-12}:\\ \;\;\;\;x \cdot e^{z \cdot \left(-a\right)}\\ \mathbf{else}:\\ \;\;\;\;z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + z \cdot \left(-0.5 \cdot \left(z \cdot \left(x \cdot a\right)\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 59.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\ \mathbf{if}\;t\_1 \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{elif}\;t\_1 \leq 10^{-12}:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \left(z \cdot z\right), a \cdot \left(\left(-b\right) - z\right)\right), x\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + z \cdot \left(-0.5 \cdot \left(z \cdot \left(x \cdot a\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
   (if (<= t_1 -200000.0)
     (* (* a -0.5) (* x (* z z)))
     (if (<= t_1 1e-12)
       (fma x (fma -0.5 (* a (* z z)) (* a (- (- b) z))) x)
       (+
        (* z (fma a (- x) (/ (fma (* a b) (- x) x) z)))
        (* z (* -0.5 (* z (* x a)))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
	double tmp;
	if (t_1 <= -200000.0) {
		tmp = (a * -0.5) * (x * (z * z));
	} else if (t_1 <= 1e-12) {
		tmp = fma(x, fma(-0.5, (a * (z * z)), (a * (-b - z))), x);
	} else {
		tmp = (z * fma(a, -x, (fma((a * b), -x, x) / z))) + (z * (-0.5 * (z * (x * a))));
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))
	tmp = 0.0
	if (t_1 <= -200000.0)
		tmp = Float64(Float64(a * -0.5) * Float64(x * Float64(z * z)));
	elseif (t_1 <= 1e-12)
		tmp = fma(x, fma(-0.5, Float64(a * Float64(z * z)), Float64(a * Float64(Float64(-b) - z))), x);
	else
		tmp = Float64(Float64(z * fma(a, Float64(-x), Float64(fma(Float64(a * b), Float64(-x), x) / z))) + Float64(z * Float64(-0.5 * Float64(z * Float64(x * a)))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = 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]}, If[LessEqual[t$95$1, -200000.0], N[(N[(a * -0.5), $MachinePrecision] * N[(x * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e-12], N[(x * N[(-0.5 * N[(a * N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(N[(z * N[(a * (-x) + N[(N[(N[(a * b), $MachinePrecision] * (-x) + x), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(-0.5 * N[(z * N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -2e5

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 58.6%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.8%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 3.7%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto \frac{-1}{2} \cdot \left(a \cdot \left(x \cdot \color{blue}{{z}^{2}}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 65.1%

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

   if -2e5 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 9.9999999999999998e-13

   1. Initial program 94.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 91.5%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 86.9%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 84.3%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in x around 0

       \[\leadsto x \cdot \left(1 + \left(-1 \cdot \left(a \cdot \left(b + z\right)\right) + \color{blue}{\frac{-1}{2} \cdot \left(a \cdot {z}^{2}\right)}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 92.8%

       \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \color{blue}{\left(z \cdot z\right)}, \left(-a\right) \cdot \left(z + b\right)\right), x\right) \]

   if 9.9999999999999998e-13 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 68.4%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 24.1%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 19.4%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto z \cdot \left(-1 \cdot \left(a \cdot x\right) + \left(-1 \cdot \frac{a \cdot \left(b \cdot x\right)}{z} + \frac{x}{z}\right)\right) + \left(\frac{-1}{2} \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot z \]
   13. Step-by-step derivation

   14. Applied rewrites 39.9%

       \[\leadsto z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot z \]
3. Recombined 3 regimes into one program.

4. Final simplification 58.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{elif}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq 10^{-12}:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \left(z \cdot z\right), a \cdot \left(\left(-b\right) - z\right)\right), x\right)\\ \mathbf{else}:\\ \;\;\;\;z \cdot \mathsf{fma}\left(a, -x, \frac{\mathsf{fma}\left(a \cdot b, -x, x\right)}{z}\right) + z \cdot \left(-0.5 \cdot \left(z \cdot \left(x \cdot a\right)\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 35.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\ \mathbf{if}\;t\_1 \leq -4 \cdot 10^{+242}:\\ \;\;\;\;a \cdot \frac{x}{a}\\ \mathbf{elif}\;t\_1 \leq -1 \cdot 10^{+14}:\\ \;\;\;\;\left(-b\right) \cdot \left(x \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;x - x \cdot \left(a \cdot b\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
   (if (<= t_1 -4e+242)
     (* a (/ x a))
     (if (<= t_1 -1e+14) (* (- b) (* x a)) (- x (* x (* a b)))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
	double tmp;
	if (t_1 <= -4e+242) {
		tmp = a * (x / a);
	} else if (t_1 <= -1e+14) {
		tmp = -b * (x * a);
	} else {
		tmp = x - (x * (a * b));
	}
	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) :: tmp
    t_1 = (y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))
    if (t_1 <= (-4d+242)) then
        tmp = a * (x / a)
    else if (t_1 <= (-1d+14)) then
        tmp = -b * (x * a)
    else
        tmp = x - (x * (a * b))
    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 = (y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b));
	double tmp;
	if (t_1 <= -4e+242) {
		tmp = a * (x / a);
	} else if (t_1 <= -1e+14) {
		tmp = -b * (x * a);
	} else {
		tmp = x - (x * (a * b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = (y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))
	tmp = 0
	if t_1 <= -4e+242:
		tmp = a * (x / a)
	elif t_1 <= -1e+14:
		tmp = -b * (x * a)
	else:
		tmp = x - (x * (a * b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))
	tmp = 0.0
	if (t_1 <= -4e+242)
		tmp = Float64(a * Float64(x / a));
	elseif (t_1 <= -1e+14)
		tmp = Float64(Float64(-b) * Float64(x * a));
	else
		tmp = Float64(x - Float64(x * Float64(a * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
	tmp = 0.0;
	if (t_1 <= -4e+242)
		tmp = a * (x / a);
	elseif (t_1 <= -1e+14)
		tmp = -b * (x * a);
	else
		tmp = x - (x * (a * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = 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]}, If[LessEqual[t$95$1, -4e+242], N[(a * N[(x / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -1e+14], N[((-b) * N[(x * a), $MachinePrecision]), $MachinePrecision], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.0000000000000002e242

   1. Initial program 100.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 53.6%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 2.5%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in a around inf

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

   11. Applied rewrites 6.3%

       \[\leadsto a \cdot \mathsf{fma}\left(x, \color{blue}{\mathsf{log1p}\left(-z\right) - b}, \frac{x}{a}\right) \]

   12. Taylor expanded in a around 0

       \[\leadsto a \cdot \frac{x}{a} \]
   13. Step-by-step derivation

   14. Applied rewrites 22.9%

       \[\leadsto a \cdot \frac{x}{a} \]

   if -4.0000000000000002e242 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -1e14

   1. Initial program 96.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 a around 0

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 65.0%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 5.0%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in b around inf

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

   11. Applied rewrites 20.4%

       \[\leadsto \left(a \cdot \left(-b\right)\right) \cdot x \]
   12. Step-by-step derivation

   13. Applied rewrites 22.1%

       \[\leadsto \left(a \cdot x\right) \cdot \left(-b\right) \]

   if -1e14 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   1. Initial program 97.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 73.3%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 39.6%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 43.5%

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

4. Final simplification 34.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -4 \cdot 10^{+242}:\\ \;\;\;\;a \cdot \frac{x}{a}\\ \mathbf{elif}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -1 \cdot 10^{+14}:\\ \;\;\;\;\left(-b\right) \cdot \left(x \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;x - x \cdot \left(a \cdot b\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 64.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -1 \cdot 10^{+14}:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))) -1e+14)
   (* (* a -0.5) (* x (* z z)))
   (* x (exp (* a (- b))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -1e+14) {
		tmp = (a * -0.5) * (x * (z * z));
	} else {
		tmp = x * exp((a * -b));
	}
	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 * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))) <= (-1d+14)) then
        tmp = (a * (-0.5d0)) * (x * (z * z))
    else
        tmp = x * exp((a * -b))
    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 * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))) <= -1e+14) {
		tmp = (a * -0.5) * (x * (z * z));
	} else {
		tmp = x * Math.exp((a * -b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if ((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))) <= -1e+14:
		tmp = (a * -0.5) * (x * (z * z))
	else:
		tmp = x * math.exp((a * -b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) <= -1e+14)
		tmp = Float64(Float64(a * -0.5) * Float64(x * Float64(z * z)));
	else
		tmp = Float64(x * exp(Float64(a * Float64(-b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -1e+14)
		tmp = (a * -0.5) * (x * (z * z));
	else
		tmp = x * exp((a * -b));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[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], -1e+14], N[(N[(a * -0.5), $MachinePrecision] * N[(x * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -1e14

   1. Initial program 98.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 59.7%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.9%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 3.8%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto \frac{-1}{2} \cdot \left(a \cdot \left(x \cdot \color{blue}{{z}^{2}}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 65.3%

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

   if -1e14 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   1. Initial program 97.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 b around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 N/A

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

      3. lower-*.f64 63.4

         \[\leadsto x \cdot e^{-\color{blue}{a \cdot b}} \]

   5. Applied rewrites 63.4%

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

4. Final simplification 64.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -1 \cdot 10^{+14}:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 54.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \left(z \cdot z\right), a \cdot \left(\left(-b\right) - z\right)\right), x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))) -200000.0)
   (* (* a -0.5) (* x (* z z)))
   (fma x (fma -0.5 (* a (* z z)) (* a (- (- b) z))) x)))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -200000.0) {
		tmp = (a * -0.5) * (x * (z * z));
	} else {
		tmp = fma(x, fma(-0.5, (a * (z * z)), (a * (-b - z))), x);
	}
	return tmp;
}

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) <= -200000.0)
		tmp = Float64(Float64(a * -0.5) * Float64(x * Float64(z * z)));
	else
		tmp = fma(x, fma(-0.5, Float64(a * Float64(z * z)), Float64(a * Float64(Float64(-b) - z))), x);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[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], -200000.0], N[(N[(a * -0.5), $MachinePrecision] * N[(x * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(-0.5 * N[(a * N[(z * z), $MachinePrecision]), $MachinePrecision] + N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -2e5

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 58.6%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.8%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 3.7%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto \frac{-1}{2} \cdot \left(a \cdot \left(x \cdot \color{blue}{{z}^{2}}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 65.1%

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

   if -2e5 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   1. Initial program 97.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 74.3%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 40.1%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 35.9%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in x around 0

       \[\leadsto x \cdot \left(1 + \left(-1 \cdot \left(a \cdot \left(b + z\right)\right) + \color{blue}{\frac{-1}{2} \cdot \left(a \cdot {z}^{2}\right)}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 45.5%

       \[\leadsto \mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \color{blue}{\left(z \cdot z\right)}, \left(-a\right) \cdot \left(z + b\right)\right), x\right) \]
3. Recombined 2 regimes into one program.

4. Final simplification 53.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(-0.5, a \cdot \left(z \cdot z\right), a \cdot \left(\left(-b\right) - z\right)\right), x\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 54.0% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x - x \cdot \left(a \cdot b\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))) -200000.0)
   (* (* a -0.5) (* x (* z z)))
   (- x (* x (* a b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -200000.0) {
		tmp = (a * -0.5) * (x * (z * z));
	} else {
		tmp = x - (x * (a * b));
	}
	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 * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))) <= (-200000.0d0)) then
        tmp = (a * (-0.5d0)) * (x * (z * z))
    else
        tmp = x - (x * (a * b))
    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 * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))) <= -200000.0) {
		tmp = (a * -0.5) * (x * (z * z));
	} else {
		tmp = x - (x * (a * b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if ((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))) <= -200000.0:
		tmp = (a * -0.5) * (x * (z * z))
	else:
		tmp = x - (x * (a * b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) <= -200000.0)
		tmp = Float64(Float64(a * -0.5) * Float64(x * Float64(z * z)));
	else
		tmp = Float64(x - Float64(x * Float64(a * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -200000.0)
		tmp = (a * -0.5) * (x * (z * z));
	else
		tmp = x - (x * (a * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[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], -200000.0], N[(N[(a * -0.5), $MachinePrecision] * N[(x * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -2e5

   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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 58.6%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.8%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 3.7%

       \[\leadsto \mathsf{fma}\left(a, \left(-x\right) \cdot \left(z + b\right), x\right) + \left(-0.5 \cdot \left(\left(x \cdot a\right) \cdot z\right)\right) \cdot \color{blue}{z} \]

   12. Taylor expanded in z around inf

       \[\leadsto \frac{-1}{2} \cdot \left(a \cdot \left(x \cdot \color{blue}{{z}^{2}}\right)\right) \]
   13. Step-by-step derivation

   14. Applied rewrites 65.1%

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

   if -2e5 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   1. Initial program 97.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 74.3%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 40.1%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 44.0%

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

4. Final simplification 52.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -200000:\\ \;\;\;\;\left(a \cdot -0.5\right) \cdot \left(x \cdot \left(z \cdot z\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x - x \cdot \left(a \cdot b\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 34.7% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq -1 \cdot 10^{+14}:\\ \;\;\;\;\left(-b\right) \cdot \left(x \cdot a\right)\\ \mathbf{else}:\\ \;\;\;\;x - x \cdot \left(a \cdot b\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))) -1e+14)
   (* (- b) (* x a))
   (- x (* x (* a b)))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -1e+14) {
		tmp = -b * (x * a);
	} else {
		tmp = x - (x * (a * b));
	}
	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 * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))) <= (-1d+14)) then
        tmp = -b * (x * a)
    else
        tmp = x - (x * (a * b))
    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 * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b))) <= -1e+14) {
		tmp = -b * (x * a);
	} else {
		tmp = x - (x * (a * b));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if ((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))) <= -1e+14:
		tmp = -b * (x * a)
	else:
		tmp = x - (x * (a * b))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) <= -1e+14)
		tmp = Float64(Float64(-b) * Float64(x * a));
	else
		tmp = Float64(x - Float64(x * Float64(a * b)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= -1e+14)
		tmp = -b * (x * a);
	else
		tmp = x - (x * (a * b));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[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], -1e+14], N[((-b) * N[(x * a), $MachinePrecision]), $MachinePrecision], N[(x - N[(x * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -1e14

   1. Initial program 98.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 59.7%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 3.9%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in b around inf

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

   11. Applied rewrites 17.6%

       \[\leadsto \left(a \cdot \left(-b\right)\right) \cdot x \]
   12. Step-by-step derivation

   13. Applied rewrites 17.6%

       \[\leadsto \left(a \cdot x\right) \cdot \left(-b\right) \]

   if -1e14 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))

   1. Initial program 97.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

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

      1. associate-*r* N/A

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

      2. *-commutative N/A

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

      3. associate-*r* N/A

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

      4. distribute-rgt-out N/A

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

      5. lower-*.f64 N/A

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

      6. lower-exp.f64 N/A

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

      7. lower-*.f64 N/A

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

      8. lower--.f64 N/A

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

      9. lower-log.f64 N/A

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

      10. lower-fma.f64 N/A

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

   5. Applied rewrites 73.3%

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

   6. Taylor expanded in y around 0

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

   8. Applied rewrites 39.6%

      \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

   9. Taylor expanded in z around 0

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

   11. Applied rewrites 43.5%

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

4. Final simplification 32.8%

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

Alternative 9: 86.2% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot e^{y \cdot \left(\log z - t\right)}\\ \mathbf{if}\;y \leq -5.6 \cdot 10^{-90}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 10^{-22}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (exp (* y (- (log z) t))))))
   (if (<= y -5.6e-90)
     t_1
     (if (<= y 1e-22) (* x (exp (* a (- (- b) z)))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * exp((y * (log(z) - t)));
	double tmp;
	if (y <= -5.6e-90) {
		tmp = t_1;
	} else if (y <= 1e-22) {
		tmp = x * exp((a * (-b - z)));
	} 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) :: tmp
    t_1 = x * exp((y * (log(z) - t)))
    if (y <= (-5.6d-90)) then
        tmp = t_1
    else if (y <= 1d-22) then
        tmp = x * exp((a * (-b - 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 a, double b) {
	double t_1 = x * Math.exp((y * (Math.log(z) - t)));
	double tmp;
	if (y <= -5.6e-90) {
		tmp = t_1;
	} else if (y <= 1e-22) {
		tmp = x * Math.exp((a * (-b - z)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.exp((y * (math.log(z) - t)))
	tmp = 0
	if y <= -5.6e-90:
		tmp = t_1
	elif y <= 1e-22:
		tmp = x * math.exp((a * (-b - z)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * exp(Float64(y * Float64(log(z) - t))))
	tmp = 0.0
	if (y <= -5.6e-90)
		tmp = t_1;
	elseif (y <= 1e-22)
		tmp = Float64(x * exp(Float64(a * Float64(Float64(-b) - z))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * exp((y * (log(z) - t)));
	tmp = 0.0;
	if (y <= -5.6e-90)
		tmp = t_1;
	elseif (y <= 1e-22)
		tmp = x * exp((a * (-b - z)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.6e-90], t$95$1, If[LessEqual[y, 1e-22], N[(x * N[Exp[N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if y < -5.5999999999999998e-90 or 1e-22 < y

   1. Initial program 100.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 y around inf

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. lower-log.f64 90.0

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

   5. Applied rewrites 90.0%

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

   if -5.5999999999999998e-90 < y < 1e-22

   1. Initial program 94.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 y around 0

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. sub-neg N/A

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

      4. lower-log1p.f64 N/A

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

      5. lower-neg.f64 87.0

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

   5. Applied rewrites 87.0%

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

   6. Taylor expanded in z around 0

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

   8. Applied rewrites 87.0%

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

Alternative 10: 76.3% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot e^{y \cdot \log z}\\ \mathbf{if}\;y \leq -2.05 \cdot 10^{+76}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq 102000000000:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (exp (* y (log z))))))
   (if (<= y -2.05e+76)
     t_1
     (if (<= y 102000000000.0) (* x (exp (* a (- (- b) z)))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * exp((y * log(z)));
	double tmp;
	if (y <= -2.05e+76) {
		tmp = t_1;
	} else if (y <= 102000000000.0) {
		tmp = x * exp((a * (-b - z)));
	} 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) :: tmp
    t_1 = x * exp((y * log(z)))
    if (y <= (-2.05d+76)) then
        tmp = t_1
    else if (y <= 102000000000.0d0) then
        tmp = x * exp((a * (-b - 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 a, double b) {
	double t_1 = x * Math.exp((y * Math.log(z)));
	double tmp;
	if (y <= -2.05e+76) {
		tmp = t_1;
	} else if (y <= 102000000000.0) {
		tmp = x * Math.exp((a * (-b - z)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.exp((y * math.log(z)))
	tmp = 0
	if y <= -2.05e+76:
		tmp = t_1
	elif y <= 102000000000.0:
		tmp = x * math.exp((a * (-b - z)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * exp(Float64(y * log(z))))
	tmp = 0.0
	if (y <= -2.05e+76)
		tmp = t_1;
	elseif (y <= 102000000000.0)
		tmp = Float64(x * exp(Float64(a * Float64(Float64(-b) - z))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * exp((y * log(z)));
	tmp = 0.0;
	if (y <= -2.05e+76)
		tmp = t_1;
	elseif (y <= 102000000000.0)
		tmp = x * exp((a * (-b - z)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.05e+76], t$95$1, If[LessEqual[y, 102000000000.0], N[(x * N[Exp[N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if y < -2.0499999999999999e76 or 1.02e11 < y

   1. Initial program 100.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 y around inf

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. lower-log.f64 95.2

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

   5. Applied rewrites 95.2%

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

   6. Taylor expanded in t around 0

      \[\leadsto x \cdot e^{y \cdot \log z} \]
   7. Step-by-step derivation

   8. Applied rewrites 75.2%

      \[\leadsto x \cdot e^{y \cdot \log z} \]

   if -2.0499999999999999e76 < y < 1.02e11

   1. Initial program 96.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 y around 0

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. sub-neg N/A

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

      4. lower-log1p.f64 N/A

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

      5. lower-neg.f64 81.1

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

   5. Applied rewrites 81.1%

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

   6. Taylor expanded in z around 0

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

   8. Applied rewrites 81.1%

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

Alternative 11: 72.2% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -2.05 \cdot 10^{+192}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-36}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{-y \cdot \frac{t \cdot t}{t}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (if (<= t -2.05e+192)
   (* x (exp (* y (- t))))
   (if (<= t 4e-36)
     (* x (exp (* a (- (- b) z))))
     (* x (exp (- (* y (/ (* t t) t))))))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double tmp;
	if (t <= -2.05e+192) {
		tmp = x * exp((y * -t));
	} else if (t <= 4e-36) {
		tmp = x * exp((a * (-b - z)));
	} else {
		tmp = x * exp(-(y * ((t * t) / 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 (t <= (-2.05d+192)) then
        tmp = x * exp((y * -t))
    else if (t <= 4d-36) then
        tmp = x * exp((a * (-b - z)))
    else
        tmp = x * exp(-(y * ((t * t) / 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 (t <= -2.05e+192) {
		tmp = x * Math.exp((y * -t));
	} else if (t <= 4e-36) {
		tmp = x * Math.exp((a * (-b - z)));
	} else {
		tmp = x * Math.exp(-(y * ((t * t) / t)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	tmp = 0
	if t <= -2.05e+192:
		tmp = x * math.exp((y * -t))
	elif t <= 4e-36:
		tmp = x * math.exp((a * (-b - z)))
	else:
		tmp = x * math.exp(-(y * ((t * t) / t)))
	return tmp

Julia

function code(x, y, z, t, a, b)
	tmp = 0.0
	if (t <= -2.05e+192)
		tmp = Float64(x * exp(Float64(y * Float64(-t))));
	elseif (t <= 4e-36)
		tmp = Float64(x * exp(Float64(a * Float64(Float64(-b) - z))));
	else
		tmp = Float64(x * exp(Float64(-Float64(y * Float64(Float64(t * t) / t)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	tmp = 0.0;
	if (t <= -2.05e+192)
		tmp = x * exp((y * -t));
	elseif (t <= 4e-36)
		tmp = x * exp((a * (-b - z)));
	else
		tmp = x * exp(-(y * ((t * t) / t)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.05e+192], N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4e-36], N[(x * N[Exp[N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(x * N[Exp[(-N[(y * N[(N[(t * t), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -2.05000000000000001e192

   1. Initial program 100.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 t around inf

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

      1. mul-1-neg N/A

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

      2. *-commutative N/A

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

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

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

      4. lower-*.f64 N/A

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

      5. lower-neg.f64 88.4

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

   5. Applied rewrites 88.4%

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

   if -2.05000000000000001e192 < t < 3.9999999999999998e-36

   1. Initial program 96.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 y around 0

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. sub-neg N/A

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

      4. lower-log1p.f64 N/A

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

      5. lower-neg.f64 72.2

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

   5. Applied rewrites 72.2%

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

   6. Taylor expanded in z around 0

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

   8. Applied rewrites 72.2%

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

   if 3.9999999999999998e-36 < t

   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 t around inf

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

      1. mul-1-neg N/A

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

      2. *-commutative N/A

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

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

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

      4. lower-*.f64 N/A

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

      5. lower-neg.f64 80.6

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

   5. Applied rewrites 80.6%

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

   7. Applied rewrites 81.9%

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

4. Final simplification 76.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2.05 \cdot 10^{+192}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-36}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{-y \cdot \frac{t \cdot t}{t}}\\ \end{array} \]
5. Add Preprocessing

Alternative 12: 72.6% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{if}\;t \leq -2.05 \cdot 10^{+192}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-36}:\\ \;\;\;\;x \cdot e^{a \cdot \left(\left(-b\right) - z\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (exp (* y (- t))))))
   (if (<= t -2.05e+192)
     t_1
     (if (<= t 4e-36) (* x (exp (* a (- (- b) z)))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * exp((y * -t));
	double tmp;
	if (t <= -2.05e+192) {
		tmp = t_1;
	} else if (t <= 4e-36) {
		tmp = x * exp((a * (-b - z)));
	} 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) :: tmp
    t_1 = x * exp((y * -t))
    if (t <= (-2.05d+192)) then
        tmp = t_1
    else if (t <= 4d-36) then
        tmp = x * exp((a * (-b - 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 a, double b) {
	double t_1 = x * Math.exp((y * -t));
	double tmp;
	if (t <= -2.05e+192) {
		tmp = t_1;
	} else if (t <= 4e-36) {
		tmp = x * Math.exp((a * (-b - z)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.exp((y * -t))
	tmp = 0
	if t <= -2.05e+192:
		tmp = t_1
	elif t <= 4e-36:
		tmp = x * math.exp((a * (-b - z)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * exp(Float64(y * Float64(-t))))
	tmp = 0.0
	if (t <= -2.05e+192)
		tmp = t_1;
	elseif (t <= 4e-36)
		tmp = Float64(x * exp(Float64(a * Float64(Float64(-b) - z))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * exp((y * -t));
	tmp = 0.0;
	if (t <= -2.05e+192)
		tmp = t_1;
	elseif (t <= 4e-36)
		tmp = x * exp((a * (-b - z)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.05e+192], t$95$1, If[LessEqual[t, 4e-36], N[(x * N[Exp[N[(a * N[((-b) - z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if t < -2.05000000000000001e192 or 3.9999999999999998e-36 < t

   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 t around inf

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

      1. mul-1-neg N/A

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

      2. *-commutative N/A

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

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

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

      4. lower-*.f64 N/A

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

      5. lower-neg.f64 82.6

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

   5. Applied rewrites 82.6%

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

   if -2.05000000000000001e192 < t < 3.9999999999999998e-36

   1. Initial program 96.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 y around 0

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

      1. lower-*.f64 N/A

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

      2. lower--.f64 N/A

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

      3. sub-neg N/A

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

      4. lower-log1p.f64 N/A

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

      5. lower-neg.f64 72.2

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

   5. Applied rewrites 72.2%

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

   6. Taylor expanded in z around 0

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

   8. Applied rewrites 72.2%

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

Alternative 13: 70.8% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{if}\;t \leq -2.9 \cdot 10^{+158}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-36}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b)
 :precision binary64
 (let* ((t_1 (* x (exp (* y (- t))))))
   (if (<= t -2.9e+158) t_1 (if (<= t 4e-36) (* x (exp (* a (- b)))) t_1))))

C

double code(double x, double y, double z, double t, double a, double b) {
	double t_1 = x * exp((y * -t));
	double tmp;
	if (t <= -2.9e+158) {
		tmp = t_1;
	} else if (t <= 4e-36) {
		tmp = x * exp((a * -b));
	} 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) :: tmp
    t_1 = x * exp((y * -t))
    if (t <= (-2.9d+158)) then
        tmp = t_1
    else if (t <= 4d-36) then
        tmp = x * exp((a * -b))
    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.exp((y * -t));
	double tmp;
	if (t <= -2.9e+158) {
		tmp = t_1;
	} else if (t <= 4e-36) {
		tmp = x * Math.exp((a * -b));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b):
	t_1 = x * math.exp((y * -t))
	tmp = 0
	if t <= -2.9e+158:
		tmp = t_1
	elif t <= 4e-36:
		tmp = x * math.exp((a * -b))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b)
	t_1 = Float64(x * exp(Float64(y * Float64(-t))))
	tmp = 0.0
	if (t <= -2.9e+158)
		tmp = t_1;
	elseif (t <= 4e-36)
		tmp = Float64(x * exp(Float64(a * Float64(-b))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b)
	t_1 = x * exp((y * -t));
	tmp = 0.0;
	if (t <= -2.9e+158)
		tmp = t_1;
	elseif (t <= 4e-36)
		tmp = x * exp((a * -b));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(y * (-t)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.9e+158], t$95$1, If[LessEqual[t, 4e-36], N[(x * N[Exp[N[(a * (-b)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if t < -2.90000000000000024e158 or 3.9999999999999998e-36 < t

   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 t around inf

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

      1. mul-1-neg N/A

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

      2. *-commutative N/A

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

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

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

      4. lower-*.f64 N/A

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

      5. lower-neg.f64 81.3

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

   5. Applied rewrites 81.3%

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

   if -2.90000000000000024e158 < t < 3.9999999999999998e-36

   1. Initial program 97.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 b around inf

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 N/A

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

      3. lower-*.f64 67.0

         \[\leadsto x \cdot e^{-\color{blue}{a \cdot b}} \]

   5. Applied rewrites 67.0%

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

4. Final simplification 73.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t \leq -2.9 \cdot 10^{+158}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \mathbf{elif}\;t \leq 4 \cdot 10^{-36}:\\ \;\;\;\;x \cdot e^{a \cdot \left(-b\right)}\\ \mathbf{else}:\\ \;\;\;\;x \cdot e^{y \cdot \left(-t\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 14: 18.8% accurate, 25.2× speedup

Math

\[\begin{array}{l} \\ x \cdot \left(a \cdot \left(-b\right)\right) \end{array} \]

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[(x * N[(a * (-b)), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 97.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

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

   1. associate-*r* N/A

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

   2. *-commutative N/A

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

   3. associate-*r* N/A

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

   4. distribute-rgt-out N/A

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

   5. lower-*.f64 N/A

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

   6. lower-exp.f64 N/A

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

   7. lower-*.f64 N/A

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

   8. lower--.f64 N/A

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

   9. lower-log.f64 N/A

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

   10. lower-fma.f64 N/A

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

5. Applied rewrites 67.7%

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

6. Taylor expanded in y around 0

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

8. Applied rewrites 24.9%

   \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

9. Taylor expanded in b around inf

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

11. Applied rewrites 18.9%

    \[\leadsto \left(a \cdot \left(-b\right)\right) \cdot x \]

12. Final simplification 18.9%

    \[\leadsto x \cdot \left(a \cdot \left(-b\right)\right) \]
13. Add Preprocessing

Alternative 15: 17.9% accurate, 25.2× speedup

Math

\[\begin{array}{l} \\ \left(-b\right) \cdot \left(x \cdot a\right) \end{array} \]

FPCore

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

C

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

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 = -b * (x * a)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_, a_, b_] := N[((-b) * N[(x * a), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 97.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

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

   1. associate-*r* N/A

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

   2. *-commutative N/A

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

   3. associate-*r* N/A

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

   4. distribute-rgt-out N/A

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

   5. lower-*.f64 N/A

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

   6. lower-exp.f64 N/A

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

   7. lower-*.f64 N/A

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

   8. lower--.f64 N/A

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

   9. lower-log.f64 N/A

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

   10. lower-fma.f64 N/A

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

5. Applied rewrites 67.7%

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

6. Taylor expanded in y around 0

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

8. Applied rewrites 24.9%

   \[\leadsto \mathsf{fma}\left(a, \color{blue}{x \cdot \left(\mathsf{log1p}\left(-z\right) - b\right)}, x\right) \]

9. Taylor expanded in b around inf

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

11. Applied rewrites 18.9%

    \[\leadsto \left(a \cdot \left(-b\right)\right) \cdot x \]
12. Step-by-step derivation

13. Applied rewrites 17.0%

    \[\leadsto \left(a \cdot x\right) \cdot \left(-b\right) \]

14. Final simplification 17.0%

    \[\leadsto \left(-b\right) \cdot \left(x \cdot a\right) \]
15. Add Preprocessing

Reproduce

herbie shell --seed 2024222 
(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))))))