Numeric.SpecFunctions:invIncompleteBetaWorker from math-functions-0.1.5.2, I

Percentage Accurate: 94.0% → 96.1%

Time: 31.1s

Alternatives: 26

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (/
  x
  (+
   x
   (*
    y
    (exp
     (*
      2.0
      (-
       (/ (* z (sqrt (+ t a))) t)
       (* (- b c) (- (+ a (/ 5.0 6.0)) (/ 2.0 (* t 3.0)))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return x / (x + (y * exp((2.0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    code = x / (x + (y * exp((2.0d0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0d0 / 6.0d0)) - (2.0d0 / (t * 3.0d0)))))))))
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	return x / (x + (y * Math.exp((2.0 * (((z * Math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
}

Python

def code(x, y, z, t, a, b, c):
	return x / (x + (y * math.exp((2.0 * (((z * math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))))

Julia

function code(x, y, z, t, a, b, c)
	return Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(Float64(z * sqrt(Float64(t + a))) / t) - Float64(Float64(b - c) * Float64(Float64(a + Float64(5.0 / 6.0)) - Float64(2.0 / Float64(t * 3.0))))))))))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = x / (x + (y * exp((2.0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[(z * N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(N[(a + N[(5.0 / 6.0), $MachinePrecision]), $MachinePrecision] - N[(2.0 / N[(t * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 94.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (/
  x
  (+
   x
   (*
    y
    (exp
     (*
      2.0
      (-
       (/ (* z (sqrt (+ t a))) t)
       (* (- b c) (- (+ a (/ 5.0 6.0)) (/ 2.0 (* t 3.0)))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	return x / (x + (y * exp((2.0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    code = x / (x + (y * exp((2.0d0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0d0 / 6.0d0)) - (2.0d0 / (t * 3.0d0)))))))))
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	return x / (x + (y * Math.exp((2.0 * (((z * Math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
}

Python

def code(x, y, z, t, a, b, c):
	return x / (x + (y * math.exp((2.0 * (((z * math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))))

Julia

function code(x, y, z, t, a, b, c)
	return Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(Float64(z * sqrt(Float64(t + a))) / t) - Float64(Float64(b - c) * Float64(Float64(a + Float64(5.0 / 6.0)) - Float64(2.0 / Float64(t * 3.0))))))))))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c)
	tmp = x / (x + (y * exp((2.0 * (((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[(z * N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(N[(a + N[(5.0 / 6.0), $MachinePrecision]), $MachinePrecision] - N[(2.0 / N[(t * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 96.1% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\\ \mathbf{if}\;t\_1 \leq \infty:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot t\_1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{z \cdot \left(2 \cdot \left(\left(t \cdot \left(y \cdot \left(\frac{1}{t} + \frac{a}{t \cdot t}\right)\right)\right) \cdot \sqrt{\frac{1}{a + t}}\right) + \left(\frac{x}{z} + \frac{y}{z}\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (-
          (/ (* z (sqrt (+ t a))) t)
          (* (- b c) (- (+ a (/ 5.0 6.0)) (/ 2.0 (* t 3.0)))))))
   (if (<= t_1 INFINITY)
     (/ x (+ x (* y (exp (* 2.0 t_1)))))
     (/
      x
      (*
       z
       (+
        (*
         2.0
         (* (* t (* y (+ (/ 1.0 t) (/ a (* t t))))) (sqrt (/ 1.0 (+ a t)))))
        (+ (/ x z) (/ y z))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = ((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0))));
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = x / (x + (y * exp((2.0 * t_1))));
	} else {
		tmp = x / (z * ((2.0 * ((t * (y * ((1.0 / t) + (a / (t * t))))) * sqrt((1.0 / (a + t))))) + ((x / z) + (y / z))));
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = ((z * Math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0))));
	double tmp;
	if (t_1 <= Double.POSITIVE_INFINITY) {
		tmp = x / (x + (y * Math.exp((2.0 * t_1))));
	} else {
		tmp = x / (z * ((2.0 * ((t * (y * ((1.0 / t) + (a / (t * t))))) * Math.sqrt((1.0 / (a + t))))) + ((x / z) + (y / z))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = ((z * math.sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0))))
	tmp = 0
	if t_1 <= math.inf:
		tmp = x / (x + (y * math.exp((2.0 * t_1))))
	else:
		tmp = x / (z * ((2.0 * ((t * (y * ((1.0 / t) + (a / (t * t))))) * math.sqrt((1.0 / (a + t))))) + ((x / z) + (y / z))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(Float64(z * sqrt(Float64(t + a))) / t) - Float64(Float64(b - c) * Float64(Float64(a + Float64(5.0 / 6.0)) - Float64(2.0 / Float64(t * 3.0)))))
	tmp = 0.0
	if (t_1 <= Inf)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * t_1)))));
	else
		tmp = Float64(x / Float64(z * Float64(Float64(2.0 * Float64(Float64(t * Float64(y * Float64(Float64(1.0 / t) + Float64(a / Float64(t * t))))) * sqrt(Float64(1.0 / Float64(a + t))))) + Float64(Float64(x / z) + Float64(y / z)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = ((z * sqrt((t + a))) / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0))));
	tmp = 0.0;
	if (t_1 <= Inf)
		tmp = x / (x + (y * exp((2.0 * t_1))));
	else
		tmp = x / (z * ((2.0 * ((t * (y * ((1.0 / t) + (a / (t * t))))) * sqrt((1.0 / (a + t))))) + ((x / z) + (y / z))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(N[(z * N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(N[(a + N[(5.0 / 6.0), $MachinePrecision]), $MachinePrecision] - N[(2.0 / N[(t * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(z * N[(N[(2.0 * N[(N[(t * N[(y * N[(N[(1.0 / t), $MachinePrecision] + N[(a / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / N[(a + t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(x / z), $MachinePrecision] + N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (-.f64 (/.f64 (*.f64 z (sqrt.f64 (+.f64 t a))) t) (*.f64 (-.f64 b c) (-.f64 (+.f64 a (/.f64 #s(literal 5 binary64) #s(literal 6 binary64))) (/.f64 #s(literal 2 binary64) (*.f64 t #s(literal 3 binary64)))))) < +inf.0

   1. Initial program 99.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   if +inf.0 < (-.f64 (/.f64 (*.f64 z (sqrt.f64 (+.f64 t a))) t) (*.f64 (-.f64 b c) (-.f64 (+.f64 a (/.f64 #s(literal 5 binary64) #s(literal 6 binary64))) (/.f64 #s(literal 2 binary64) (*.f64 t #s(literal 3 binary64))))))

   1. Initial program 0.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 91.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -3.9 \cdot 10^{+102}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{elif}\;t \leq 1.82 \cdot 10^{-7}:\\ \;\;\;\;\frac{1}{\frac{x + e^{\frac{2 \cdot {\left(t + a\right)}^{0.5}}{\frac{t}{z}} + 1.3333333333333333 \cdot \frac{b - c}{t}} \cdot y}{x}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y \cdot e^{2 \cdot \left(\frac{z}{\sqrt{t}} - \left(b - c\right) \cdot \left(a + 0.8333333333333334\right)\right)} + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t -3.9e+102)
   (/ x (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))
   (if (<= t 1.82e-7)
     (/
      1.0
      (/
       (+
        x
        (*
         (exp
          (+
           (/ (* 2.0 (pow (+ t a) 0.5)) (/ t z))
           (* 1.3333333333333333 (/ (- b c) t))))
         y))
       x))
     (/
      x
      (+
       (*
        y
        (exp (* 2.0 (- (/ z (sqrt t)) (* (- b c) (+ a 0.8333333333333334))))))
       x)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -3.9e+102) {
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.82e-7) {
		tmp = 1.0 / ((x + (exp((((2.0 * pow((t + a), 0.5)) / (t / z)) + (1.3333333333333333 * ((b - c) / t)))) * y)) / x);
	} else {
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= (-3.9d+102)) then
        tmp = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    else if (t <= 1.82d-7) then
        tmp = 1.0d0 / ((x + (exp((((2.0d0 * ((t + a) ** 0.5d0)) / (t / z)) + (1.3333333333333333d0 * ((b - c) / t)))) * y)) / x)
    else
        tmp = x / ((y * exp((2.0d0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334d0)))))) + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -3.9e+102) {
		tmp = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.82e-7) {
		tmp = 1.0 / ((x + (Math.exp((((2.0 * Math.pow((t + a), 0.5)) / (t / z)) + (1.3333333333333333 * ((b - c) / t)))) * y)) / x);
	} else {
		tmp = x / ((y * Math.exp((2.0 * ((z / Math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= -3.9e+102:
		tmp = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	elif t <= 1.82e-7:
		tmp = 1.0 / ((x + (math.exp((((2.0 * math.pow((t + a), 0.5)) / (t / z)) + (1.3333333333333333 * ((b - c) / t)))) * y)) / x)
	else:
		tmp = x / ((y * math.exp((2.0 * ((z / math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= -3.9e+102)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))));
	elseif (t <= 1.82e-7)
		tmp = Float64(1.0 / Float64(Float64(x + Float64(exp(Float64(Float64(Float64(2.0 * (Float64(t + a) ^ 0.5)) / Float64(t / z)) + Float64(1.3333333333333333 * Float64(Float64(b - c) / t)))) * y)) / x));
	else
		tmp = Float64(x / Float64(Float64(y * exp(Float64(2.0 * Float64(Float64(z / sqrt(t)) - Float64(Float64(b - c) * Float64(a + 0.8333333333333334)))))) + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= -3.9e+102)
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	elseif (t <= 1.82e-7)
		tmp = 1.0 / ((x + (exp((((2.0 * ((t + a) ^ 0.5)) / (t / z)) + (1.3333333333333333 * ((b - c) / t)))) * y)) / x);
	else
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, -3.9e+102], N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.82e-7], N[(1.0 / N[(N[(x + N[(N[Exp[N[(N[(N[(2.0 * N[Power[N[(t + a), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / N[(t / z), $MachinePrecision]), $MachinePrecision] + N[(1.3333333333333333 * N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], N[(x / N[(N[(y * N[Exp[N[(2.0 * N[(N[(z / N[Sqrt[t], $MachinePrecision]), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(a + 0.8333333333333334), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.8999999999999998e102

   1. Initial program 90.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -3.8999999999999998e102 < t < 1.81999999999999989e-7

   1. Initial program 94.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.81999999999999989e-7 < t

   1. Initial program 94.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 91.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -3.9 \cdot 10^{+102}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{elif}\;t \leq 1.82 \cdot 10^{-7}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\sqrt{t + a} \cdot \frac{z}{t} + \frac{0.6666666666666666 \cdot \left(b - c\right)}{t}\right)}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y \cdot e^{2 \cdot \left(\frac{z}{\sqrt{t}} - \left(b - c\right) \cdot \left(a + 0.8333333333333334\right)\right)} + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t -3.9e+102)
   (/ x (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))
   (if (<= t 1.82e-7)
     (/
      x
      (+
       x
       (*
        y
        (exp
         (*
          2.0
          (+
           (* (sqrt (+ t a)) (/ z t))
           (/ (* 0.6666666666666666 (- b c)) t)))))))
     (/
      x
      (+
       (*
        y
        (exp (* 2.0 (- (/ z (sqrt t)) (* (- b c) (+ a 0.8333333333333334))))))
       x)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -3.9e+102) {
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.82e-7) {
		tmp = x / (x + (y * exp((2.0 * ((sqrt((t + a)) * (z / t)) + ((0.6666666666666666 * (b - c)) / t))))));
	} else {
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= (-3.9d+102)) then
        tmp = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    else if (t <= 1.82d-7) then
        tmp = x / (x + (y * exp((2.0d0 * ((sqrt((t + a)) * (z / t)) + ((0.6666666666666666d0 * (b - c)) / t))))))
    else
        tmp = x / ((y * exp((2.0d0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334d0)))))) + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -3.9e+102) {
		tmp = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.82e-7) {
		tmp = x / (x + (y * Math.exp((2.0 * ((Math.sqrt((t + a)) * (z / t)) + ((0.6666666666666666 * (b - c)) / t))))));
	} else {
		tmp = x / ((y * Math.exp((2.0 * ((z / Math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= -3.9e+102:
		tmp = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	elif t <= 1.82e-7:
		tmp = x / (x + (y * math.exp((2.0 * ((math.sqrt((t + a)) * (z / t)) + ((0.6666666666666666 * (b - c)) / t))))))
	else:
		tmp = x / ((y * math.exp((2.0 * ((z / math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= -3.9e+102)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))));
	elseif (t <= 1.82e-7)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(sqrt(Float64(t + a)) * Float64(z / t)) + Float64(Float64(0.6666666666666666 * Float64(b - c)) / t)))))));
	else
		tmp = Float64(x / Float64(Float64(y * exp(Float64(2.0 * Float64(Float64(z / sqrt(t)) - Float64(Float64(b - c) * Float64(a + 0.8333333333333334)))))) + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= -3.9e+102)
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	elseif (t <= 1.82e-7)
		tmp = x / (x + (y * exp((2.0 * ((sqrt((t + a)) * (z / t)) + ((0.6666666666666666 * (b - c)) / t))))));
	else
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, -3.9e+102], N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.82e-7], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision] + N[(N[(0.6666666666666666 * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(N[(y * N[Exp[N[(2.0 * N[(N[(z / N[Sqrt[t], $MachinePrecision]), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(a + 0.8333333333333334), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.8999999999999998e102

   1. Initial program 90.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -3.8999999999999998e102 < t < 1.81999999999999989e-7

   1. Initial program 94.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.81999999999999989e-7 < t

   1. Initial program 94.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 94.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;c \leq -1.15 \cdot 10^{+146}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(c \cdot \left(0.8333333333333334 + \left(a - \frac{0.6666666666666666}{t}\right)\right)\right)}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\sqrt{t + a} \cdot \frac{z}{t} + \left(b - c\right) \cdot \left(\left(\frac{0.6666666666666666}{t} + -0.8333333333333334\right) - a\right)\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= c -1.15e+146)
   (/
    x
    (+
     x
     (*
      y
      (exp
       (* 2.0 (* c (+ 0.8333333333333334 (- a (/ 0.6666666666666666 t)))))))))
   (/
    x
    (+
     x
     (*
      y
      (exp
       (*
        2.0
        (+
         (* (sqrt (+ t a)) (/ z t))
         (*
          (- b c)
          (- (+ (/ 0.6666666666666666 t) -0.8333333333333334) a))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (c <= -1.15e+146) {
		tmp = x / (x + (y * exp((2.0 * (c * (0.8333333333333334 + (a - (0.6666666666666666 / t))))))));
	} else {
		tmp = x / (x + (y * exp((2.0 * ((sqrt((t + a)) * (z / t)) + ((b - c) * (((0.6666666666666666 / t) + -0.8333333333333334) - a)))))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (c <= (-1.15d+146)) then
        tmp = x / (x + (y * exp((2.0d0 * (c * (0.8333333333333334d0 + (a - (0.6666666666666666d0 / t))))))))
    else
        tmp = x / (x + (y * exp((2.0d0 * ((sqrt((t + a)) * (z / t)) + ((b - c) * (((0.6666666666666666d0 / t) + (-0.8333333333333334d0)) - a)))))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (c <= -1.15e+146) {
		tmp = x / (x + (y * Math.exp((2.0 * (c * (0.8333333333333334 + (a - (0.6666666666666666 / t))))))));
	} else {
		tmp = x / (x + (y * Math.exp((2.0 * ((Math.sqrt((t + a)) * (z / t)) + ((b - c) * (((0.6666666666666666 / t) + -0.8333333333333334) - a)))))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if c <= -1.15e+146:
		tmp = x / (x + (y * math.exp((2.0 * (c * (0.8333333333333334 + (a - (0.6666666666666666 / t))))))))
	else:
		tmp = x / (x + (y * math.exp((2.0 * ((math.sqrt((t + a)) * (z / t)) + ((b - c) * (((0.6666666666666666 / t) + -0.8333333333333334) - a)))))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (c <= -1.15e+146)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(c * Float64(0.8333333333333334 + Float64(a - Float64(0.6666666666666666 / t)))))))));
	else
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(sqrt(Float64(t + a)) * Float64(z / t)) + Float64(Float64(b - c) * Float64(Float64(Float64(0.6666666666666666 / t) + -0.8333333333333334) - a))))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (c <= -1.15e+146)
		tmp = x / (x + (y * exp((2.0 * (c * (0.8333333333333334 + (a - (0.6666666666666666 / t))))))));
	else
		tmp = x / (x + (y * exp((2.0 * ((sqrt((t + a)) * (z / t)) + ((b - c) * (((0.6666666666666666 / t) + -0.8333333333333334) - a)))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[c, -1.15e+146], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(c * N[(0.8333333333333334 + N[(a - N[(0.6666666666666666 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision] * N[(z / t), $MachinePrecision]), $MachinePrecision] + N[(N[(b - c), $MachinePrecision] * N[(N[(N[(0.6666666666666666 / t), $MachinePrecision] + -0.8333333333333334), $MachinePrecision] - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if c < -1.15e146

   1. Initial program 83.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -1.15e146 < c

   1. Initial program 96.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 83.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{if}\;t \leq -1 \cdot 10^{-41}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 8 \cdot 10^{-27}:\\ \;\;\;\;\frac{x}{x + y \cdot {\left(e^{\frac{b - c}{t}}\right)}^{1.3333333333333333}}\\ \mathbf{elif}\;t \leq 16000000000:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z}{t} \cdot \sqrt{a + t}\right)}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/
          x
          (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))))
   (if (<= t -1e-41)
     t_1
     (if (<= t 8e-27)
       (/ x (+ x (* y (pow (exp (/ (- b c) t)) 1.3333333333333333))))
       (if (<= t 16000000000.0)
         (/ x (+ x (* y (exp (* 2.0 (* (/ z t) (sqrt (+ a t))))))))
         t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -1e-41) {
		tmp = t_1;
	} else if (t <= 8e-27) {
		tmp = x / (x + (y * pow(exp(((b - c) / t)), 1.3333333333333333)));
	} else if (t <= 16000000000.0) {
		tmp = x / (x + (y * exp((2.0 * ((z / t) * sqrt((a + t)))))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    if (t <= (-1d-41)) then
        tmp = t_1
    else if (t <= 8d-27) then
        tmp = x / (x + (y * (exp(((b - c) / t)) ** 1.3333333333333333d0)))
    else if (t <= 16000000000.0d0) then
        tmp = x / (x + (y * exp((2.0d0 * ((z / t) * sqrt((a + t)))))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -1e-41) {
		tmp = t_1;
	} else if (t <= 8e-27) {
		tmp = x / (x + (y * Math.pow(Math.exp(((b - c) / t)), 1.3333333333333333)));
	} else if (t <= 16000000000.0) {
		tmp = x / (x + (y * Math.exp((2.0 * ((z / t) * Math.sqrt((a + t)))))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	tmp = 0
	if t <= -1e-41:
		tmp = t_1
	elif t <= 8e-27:
		tmp = x / (x + (y * math.pow(math.exp(((b - c) / t)), 1.3333333333333333)))
	elif t <= 16000000000.0:
		tmp = x / (x + (y * math.exp((2.0 * ((z / t) * math.sqrt((a + t)))))))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))))
	tmp = 0.0
	if (t <= -1e-41)
		tmp = t_1;
	elseif (t <= 8e-27)
		tmp = Float64(x / Float64(x + Float64(y * (exp(Float64(Float64(b - c) / t)) ^ 1.3333333333333333))));
	elseif (t <= 16000000000.0)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(z / t) * sqrt(Float64(a + t))))))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	tmp = 0.0;
	if (t <= -1e-41)
		tmp = t_1;
	elseif (t <= 8e-27)
		tmp = x / (x + (y * (exp(((b - c) / t)) ^ 1.3333333333333333)));
	elseif (t <= 16000000000.0)
		tmp = x / (x + (y * exp((2.0 * ((z / t) * sqrt((a + t)))))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1e-41], t$95$1, If[LessEqual[t, 8e-27], N[(x / N[(x + N[(y * N[Power[N[Exp[N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision], 1.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 16000000000.0], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(z / t), $MachinePrecision] * N[Sqrt[N[(a + t), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if t < -1.00000000000000001e-41 or 1.6e10 < t

   1. Initial program 94.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.00000000000000001e-41 < t < 8.0000000000000003e-27

   1. Initial program 93.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 8.0000000000000003e-27 < t < 1.6e10

   1. Initial program 99.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 86.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq -4 \cdot 10^{+102}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{elif}\;t \leq 1.1 \cdot 10^{-32}:\\ \;\;\;\;\frac{x}{x + y \cdot {\left(e^{\frac{b - c}{t}}\right)}^{1.3333333333333333}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y \cdot e^{2 \cdot \left(\frac{z}{\sqrt{t}} - \left(b - c\right) \cdot \left(a + 0.8333333333333334\right)\right)} + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t -4e+102)
   (/ x (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))
   (if (<= t 1.1e-32)
     (/ x (+ x (* y (pow (exp (/ (- b c) t)) 1.3333333333333333))))
     (/
      x
      (+
       (*
        y
        (exp (* 2.0 (- (/ z (sqrt t)) (* (- b c) (+ a 0.8333333333333334))))))
       x)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -4e+102) {
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.1e-32) {
		tmp = x / (x + (y * pow(exp(((b - c) / t)), 1.3333333333333333)));
	} else {
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= (-4d+102)) then
        tmp = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    else if (t <= 1.1d-32) then
        tmp = x / (x + (y * (exp(((b - c) / t)) ** 1.3333333333333333d0)))
    else
        tmp = x / ((y * exp((2.0d0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334d0)))))) + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= -4e+102) {
		tmp = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	} else if (t <= 1.1e-32) {
		tmp = x / (x + (y * Math.pow(Math.exp(((b - c) / t)), 1.3333333333333333)));
	} else {
		tmp = x / ((y * Math.exp((2.0 * ((z / Math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= -4e+102:
		tmp = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	elif t <= 1.1e-32:
		tmp = x / (x + (y * math.pow(math.exp(((b - c) / t)), 1.3333333333333333)))
	else:
		tmp = x / ((y * math.exp((2.0 * ((z / math.sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= -4e+102)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))));
	elseif (t <= 1.1e-32)
		tmp = Float64(x / Float64(x + Float64(y * (exp(Float64(Float64(b - c) / t)) ^ 1.3333333333333333))));
	else
		tmp = Float64(x / Float64(Float64(y * exp(Float64(2.0 * Float64(Float64(z / sqrt(t)) - Float64(Float64(b - c) * Float64(a + 0.8333333333333334)))))) + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= -4e+102)
		tmp = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	elseif (t <= 1.1e-32)
		tmp = x / (x + (y * (exp(((b - c) / t)) ^ 1.3333333333333333)));
	else
		tmp = x / ((y * exp((2.0 * ((z / sqrt(t)) - ((b - c) * (a + 0.8333333333333334)))))) + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, -4e+102], N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.1e-32], N[(x / N[(x + N[(y * N[Power[N[Exp[N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision], 1.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(N[(y * N[Exp[N[(2.0 * N[(N[(z / N[Sqrt[t], $MachinePrecision]), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(a + 0.8333333333333334), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if t < -3.99999999999999991e102

   1. Initial program 90.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -3.99999999999999991e102 < t < 1.1e-32

   1. Initial program 93.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.1e-32 < t

   1. Initial program 95.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 83.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{if}\;t \leq -2 \cdot 10^{-58}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.4 \cdot 10^{-20}:\\ \;\;\;\;\frac{x}{x + y \cdot {\left(e^{\frac{b - c}{t}}\right)}^{1.3333333333333333}}\\ \mathbf{elif}\;t \leq 26000000000:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\sqrt{\frac{1}{t}} \cdot z\right)}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/
          x
          (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))))
   (if (<= t -2e-58)
     t_1
     (if (<= t 2.4e-20)
       (/ x (+ x (* y (pow (exp (/ (- b c) t)) 1.3333333333333333))))
       (if (<= t 26000000000.0)
         (/ x (+ x (* y (exp (* 2.0 (* (sqrt (/ 1.0 t)) z))))))
         t_1)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -2e-58) {
		tmp = t_1;
	} else if (t <= 2.4e-20) {
		tmp = x / (x + (y * pow(exp(((b - c) / t)), 1.3333333333333333)));
	} else if (t <= 26000000000.0) {
		tmp = x / (x + (y * exp((2.0 * (sqrt((1.0 / t)) * z)))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    if (t <= (-2d-58)) then
        tmp = t_1
    else if (t <= 2.4d-20) then
        tmp = x / (x + (y * (exp(((b - c) / t)) ** 1.3333333333333333d0)))
    else if (t <= 26000000000.0d0) then
        tmp = x / (x + (y * exp((2.0d0 * (sqrt((1.0d0 / t)) * z)))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -2e-58) {
		tmp = t_1;
	} else if (t <= 2.4e-20) {
		tmp = x / (x + (y * Math.pow(Math.exp(((b - c) / t)), 1.3333333333333333)));
	} else if (t <= 26000000000.0) {
		tmp = x / (x + (y * Math.exp((2.0 * (Math.sqrt((1.0 / t)) * z)))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	tmp = 0
	if t <= -2e-58:
		tmp = t_1
	elif t <= 2.4e-20:
		tmp = x / (x + (y * math.pow(math.exp(((b - c) / t)), 1.3333333333333333)))
	elif t <= 26000000000.0:
		tmp = x / (x + (y * math.exp((2.0 * (math.sqrt((1.0 / t)) * z)))))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))))
	tmp = 0.0
	if (t <= -2e-58)
		tmp = t_1;
	elseif (t <= 2.4e-20)
		tmp = Float64(x / Float64(x + Float64(y * (exp(Float64(Float64(b - c) / t)) ^ 1.3333333333333333))));
	elseif (t <= 26000000000.0)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(sqrt(Float64(1.0 / t)) * z))))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	tmp = 0.0;
	if (t <= -2e-58)
		tmp = t_1;
	elseif (t <= 2.4e-20)
		tmp = x / (x + (y * (exp(((b - c) / t)) ^ 1.3333333333333333)));
	elseif (t <= 26000000000.0)
		tmp = x / (x + (y * exp((2.0 * (sqrt((1.0 / t)) * z)))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2e-58], t$95$1, If[LessEqual[t, 2.4e-20], N[(x / N[(x + N[(y * N[Power[N[Exp[N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision], 1.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 26000000000.0], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[Sqrt[N[(1.0 / t), $MachinePrecision]], $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 3 regimes

2. if t < -2.0000000000000001e-58 or 2.6e10 < t

   1. Initial program 94.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -2.0000000000000001e-58 < t < 2.39999999999999993e-20

   1. Initial program 93.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.39999999999999993e-20 < t < 2.6e10

   1. Initial program 99.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 8: 82.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{if}\;t \leq -3.9 \cdot 10^{+102}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 1.2 \cdot 10^{-30}:\\ \;\;\;\;\frac{x}{x + y \cdot {\left(e^{\frac{b - c}{t}}\right)}^{1.3333333333333333}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/
          x
          (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))))
   (if (<= t -3.9e+102)
     t_1
     (if (<= t 1.2e-30)
       (/ x (+ x (* y (pow (exp (/ (- b c) t)) 1.3333333333333333))))
       t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -3.9e+102) {
		tmp = t_1;
	} else if (t <= 1.2e-30) {
		tmp = x / (x + (y * pow(exp(((b - c) / t)), 1.3333333333333333)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    if (t <= (-3.9d+102)) then
        tmp = t_1
    else if (t <= 1.2d-30) then
        tmp = x / (x + (y * (exp(((b - c) / t)) ** 1.3333333333333333d0)))
    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 c) {
	double t_1 = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -3.9e+102) {
		tmp = t_1;
	} else if (t <= 1.2e-30) {
		tmp = x / (x + (y * Math.pow(Math.exp(((b - c) / t)), 1.3333333333333333)));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	tmp = 0
	if t <= -3.9e+102:
		tmp = t_1
	elif t <= 1.2e-30:
		tmp = x / (x + (y * math.pow(math.exp(((b - c) / t)), 1.3333333333333333)))
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))))
	tmp = 0.0
	if (t <= -3.9e+102)
		tmp = t_1;
	elseif (t <= 1.2e-30)
		tmp = Float64(x / Float64(x + Float64(y * (exp(Float64(Float64(b - c) / t)) ^ 1.3333333333333333))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	tmp = 0.0;
	if (t <= -3.9e+102)
		tmp = t_1;
	elseif (t <= 1.2e-30)
		tmp = x / (x + (y * (exp(((b - c) / t)) ^ 1.3333333333333333)));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.9e+102], t$95$1, If[LessEqual[t, 1.2e-30], N[(x / N[(x + N[(y * N[Power[N[Exp[N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]], $MachinePrecision], 1.3333333333333333], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if t < -3.8999999999999998e102 or 1.19999999999999992e-30 < t

   1. Initial program 95.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -3.8999999999999998e102 < t < 1.19999999999999992e-30

   1. Initial program 93.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 83.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{x + y \cdot e^{\left(-2 \cdot \left(0.8333333333333334 + a\right)\right) \cdot \left(b - c\right)}}\\ \mathbf{if}\;t \leq -2 \cdot 10^{-78}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.5 \cdot 10^{-32}:\\ \;\;\;\;\frac{1}{\frac{x + y \cdot e^{\frac{1.3333333333333333}{\frac{t}{b - c}}}}{x}}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/
          x
          (+ x (* y (exp (* (* -2.0 (+ 0.8333333333333334 a)) (- b c))))))))
   (if (<= t -2e-78)
     t_1
     (if (<= t 2.5e-32)
       (/ 1.0 (/ (+ x (* y (exp (/ 1.3333333333333333 (/ t (- b c)))))) x))
       t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -2e-78) {
		tmp = t_1;
	} else if (t <= 2.5e-32) {
		tmp = 1.0 / ((x + (y * exp((1.3333333333333333 / (t / (b - c)))))) / x);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (x + (y * exp((((-2.0d0) * (0.8333333333333334d0 + a)) * (b - c)))))
    if (t <= (-2d-78)) then
        tmp = t_1
    else if (t <= 2.5d-32) then
        tmp = 1.0d0 / ((x + (y * exp((1.3333333333333333d0 / (t / (b - c)))))) / x)
    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 c) {
	double t_1 = x / (x + (y * Math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	double tmp;
	if (t <= -2e-78) {
		tmp = t_1;
	} else if (t <= 2.5e-32) {
		tmp = 1.0 / ((x + (y * Math.exp((1.3333333333333333 / (t / (b - c)))))) / x);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / (x + (y * math.exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))))
	tmp = 0
	if t <= -2e-78:
		tmp = t_1
	elif t <= 2.5e-32:
		tmp = 1.0 / ((x + (y * math.exp((1.3333333333333333 / (t / (b - c)))))) / x)
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(x + Float64(y * exp(Float64(Float64(-2.0 * Float64(0.8333333333333334 + a)) * Float64(b - c))))))
	tmp = 0.0
	if (t <= -2e-78)
		tmp = t_1;
	elseif (t <= 2.5e-32)
		tmp = Float64(1.0 / Float64(Float64(x + Float64(y * exp(Float64(1.3333333333333333 / Float64(t / Float64(b - c)))))) / x));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / (x + (y * exp(((-2.0 * (0.8333333333333334 + a)) * (b - c)))));
	tmp = 0.0;
	if (t <= -2e-78)
		tmp = t_1;
	elseif (t <= 2.5e-32)
		tmp = 1.0 / ((x + (y * exp((1.3333333333333333 / (t / (b - c)))))) / x);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(x + N[(y * N[Exp[N[(N[(-2.0 * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2e-78], t$95$1, If[LessEqual[t, 2.5e-32], N[(1.0 / N[(N[(x + N[(y * N[Exp[N[(1.3333333333333333 / N[(t / N[(b - c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if t < -2e-78 or 2.5e-32 < t

   1. Initial program 95.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -2e-78 < t < 2.5e-32

   1. Initial program 93.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 58.1% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(0.8333333333333334 + a\right) + -0.6666666666666666 \cdot \frac{1}{t}\\ \mathbf{if}\;c \leq -5.2 \cdot 10^{+49}:\\ \;\;\;\;1\\ \mathbf{elif}\;c \leq 1.75 \cdot 10^{+75}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{1.3333333333333333 \cdot \frac{b}{t}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{1 + y \cdot \left(2 \cdot \frac{c \cdot \left(\left(1 + c \cdot t\_1\right) \cdot t\_1\right)}{x} + \frac{1}{x}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (+ (+ 0.8333333333333334 a) (* -0.6666666666666666 (/ 1.0 t)))))
   (if (<= c -5.2e+49)
     1.0
     (if (<= c 1.75e+75)
       (/ x (+ x (* y (exp (* 1.3333333333333333 (/ b t))))))
       (/
        1.0
        (+
         1.0
         (*
          y
          (+ (* 2.0 (/ (* c (* (+ 1.0 (* c t_1)) t_1)) x)) (/ 1.0 x)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double tmp;
	if (c <= -5.2e+49) {
		tmp = 1.0;
	} else if (c <= 1.75e+75) {
		tmp = x / (x + (y * exp((1.3333333333333333 * (b / t)))));
	} else {
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (0.8333333333333334d0 + a) + ((-0.6666666666666666d0) * (1.0d0 / t))
    if (c <= (-5.2d+49)) then
        tmp = 1.0d0
    else if (c <= 1.75d+75) then
        tmp = x / (x + (y * exp((1.3333333333333333d0 * (b / t)))))
    else
        tmp = 1.0d0 / (1.0d0 + (y * ((2.0d0 * ((c * ((1.0d0 + (c * t_1)) * t_1)) / x)) + (1.0d0 / x))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double tmp;
	if (c <= -5.2e+49) {
		tmp = 1.0;
	} else if (c <= 1.75e+75) {
		tmp = x / (x + (y * Math.exp((1.3333333333333333 * (b / t)))));
	} else {
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t))
	tmp = 0
	if c <= -5.2e+49:
		tmp = 1.0
	elif c <= 1.75e+75:
		tmp = x / (x + (y * math.exp((1.3333333333333333 * (b / t)))))
	else:
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(0.8333333333333334 + a) + Float64(-0.6666666666666666 * Float64(1.0 / t)))
	tmp = 0.0
	if (c <= -5.2e+49)
		tmp = 1.0;
	elseif (c <= 1.75e+75)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(1.3333333333333333 * Float64(b / t))))));
	else
		tmp = Float64(1.0 / Float64(1.0 + Float64(y * Float64(Float64(2.0 * Float64(Float64(c * Float64(Float64(1.0 + Float64(c * t_1)) * t_1)) / x)) + Float64(1.0 / x)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	tmp = 0.0;
	if (c <= -5.2e+49)
		tmp = 1.0;
	elseif (c <= 1.75e+75)
		tmp = x / (x + (y * exp((1.3333333333333333 * (b / t)))));
	else
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(0.8333333333333334 + a), $MachinePrecision] + N[(-0.6666666666666666 * N[(1.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -5.2e+49], 1.0, If[LessEqual[c, 1.75e+75], N[(x / N[(x + N[(y * N[Exp[N[(1.3333333333333333 * N[(b / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(1.0 + N[(y * N[(N[(2.0 * N[(N[(c * N[(N[(1.0 + N[(c * t$95$1), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if c < -5.19999999999999977e49

   1. Initial program 88.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -5.19999999999999977e49 < c < 1.7499999999999999e75

   1. Initial program 96.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in b around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if 1.7499999999999999e75 < c

   1. Initial program 92.5%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 11: 72.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq 8 \cdot 10^{-32}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{1.3333333333333333 \cdot \frac{b - c}{t}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(c \cdot \left(0.8333333333333334 + a\right)\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t 8e-32)
   (/ x (+ x (* y (exp (* 1.3333333333333333 (/ (- b c) t))))))
   (/ x (+ x (* y (exp (* 2.0 (* c (+ 0.8333333333333334 a)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 8e-32) {
		tmp = x / (x + (y * exp((1.3333333333333333 * ((b - c) / t)))));
	} else {
		tmp = x / (x + (y * exp((2.0 * (c * (0.8333333333333334 + a))))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= 8d-32) then
        tmp = x / (x + (y * exp((1.3333333333333333d0 * ((b - c) / t)))))
    else
        tmp = x / (x + (y * exp((2.0d0 * (c * (0.8333333333333334d0 + a))))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 8e-32) {
		tmp = x / (x + (y * Math.exp((1.3333333333333333 * ((b - c) / t)))));
	} else {
		tmp = x / (x + (y * Math.exp((2.0 * (c * (0.8333333333333334 + a))))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= 8e-32:
		tmp = x / (x + (y * math.exp((1.3333333333333333 * ((b - c) / t)))))
	else:
		tmp = x / (x + (y * math.exp((2.0 * (c * (0.8333333333333334 + a))))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 8e-32)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(1.3333333333333333 * Float64(Float64(b - c) / t))))));
	else
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(c * Float64(0.8333333333333334 + a)))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= 8e-32)
		tmp = x / (x + (y * exp((1.3333333333333333 * ((b - c) / t)))));
	else
		tmp = x / (x + (y * exp((2.0 * (c * (0.8333333333333334 + a))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 8e-32], N[(x / N[(x + N[(y * N[Exp[N[(1.3333333333333333 * N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(c * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < 8.00000000000000045e-32

   1. Initial program 93.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 8.00000000000000045e-32 < t

   1. Initial program 95.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 64.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq 1.7 \cdot 10^{-5}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{1.3333333333333333 \cdot \frac{b - c}{t}}}\\ \mathbf{elif}\;t \leq 4.1 \cdot 10^{+74}:\\ \;\;\;\;1\\ \mathbf{elif}\;t \leq 10^{+151}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{\left(b - c\right) \cdot \left(b - c\right)}{t}}{t}\right)\right)}\\ \mathbf{elif}\;t \leq 5.8 \cdot 10^{+281}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(x + y\right) + \left(\left(0.8333333333333334 + a\right) \cdot \left(y + \left(c \cdot y\right) \cdot \left(0.8333333333333334 + a\right)\right)\right) \cdot \left(c \cdot 2\right)}{x}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t 1.7e-5)
   (/ x (+ x (* y (exp (* 1.3333333333333333 (/ (- b c) t))))))
   (if (<= t 4.1e+74)
     1.0
     (if (<= t 1e+151)
       (/
        x
        (+
         x
         (*
          y
          (+
           1.0
           (-
            (/
             (+
              (* -1.3333333333333333 (- b c))
              (* -0.8888888888888888 (/ (* (- b c) (- b c)) t)))
             t))))))
       (if (<= t 5.8e+281)
         1.0
         (/
          1.0
          (/
           (+
            (+ x y)
            (*
             (*
              (+ 0.8333333333333334 a)
              (+ y (* (* c y) (+ 0.8333333333333334 a))))
             (* c 2.0)))
           x)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 1.7e-5) {
		tmp = x / (x + (y * exp((1.3333333333333333 * ((b - c) / t)))));
	} else if (t <= 4.1e+74) {
		tmp = 1.0;
	} else if (t <= 1e+151) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if (t <= 5.8e+281) {
		tmp = 1.0;
	} else {
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)))) * (c * 2.0))) / x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= 1.7d-5) then
        tmp = x / (x + (y * exp((1.3333333333333333d0 * ((b - c) / t)))))
    else if (t <= 4.1d+74) then
        tmp = 1.0d0
    else if (t <= 1d+151) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (((b - c) * (b - c)) / t))) / t))))
    else if (t <= 5.8d+281) then
        tmp = 1.0d0
    else
        tmp = 1.0d0 / (((x + y) + (((0.8333333333333334d0 + a) * (y + ((c * y) * (0.8333333333333334d0 + a)))) * (c * 2.0d0))) / x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 1.7e-5) {
		tmp = x / (x + (y * Math.exp((1.3333333333333333 * ((b - c) / t)))));
	} else if (t <= 4.1e+74) {
		tmp = 1.0;
	} else if (t <= 1e+151) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if (t <= 5.8e+281) {
		tmp = 1.0;
	} else {
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)))) * (c * 2.0))) / x);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= 1.7e-5:
		tmp = x / (x + (y * math.exp((1.3333333333333333 * ((b - c) / t)))))
	elif t <= 4.1e+74:
		tmp = 1.0
	elif t <= 1e+151:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))))
	elif t <= 5.8e+281:
		tmp = 1.0
	else:
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)))) * (c * 2.0))) / x)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 1.7e-5)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(1.3333333333333333 * Float64(Float64(b - c) / t))))));
	elseif (t <= 4.1e+74)
		tmp = 1.0;
	elseif (t <= 1e+151)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(Float64(Float64(b - c) * Float64(b - c)) / t))) / t))))));
	elseif (t <= 5.8e+281)
		tmp = 1.0;
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(x + y) + Float64(Float64(Float64(0.8333333333333334 + a) * Float64(y + Float64(Float64(c * y) * Float64(0.8333333333333334 + a)))) * Float64(c * 2.0))) / x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= 1.7e-5)
		tmp = x / (x + (y * exp((1.3333333333333333 * ((b - c) / t)))));
	elseif (t <= 4.1e+74)
		tmp = 1.0;
	elseif (t <= 1e+151)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	elseif (t <= 5.8e+281)
		tmp = 1.0;
	else
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)))) * (c * 2.0))) / x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 1.7e-5], N[(x / N[(x + N[(y * N[Exp[N[(1.3333333333333333 * N[(N[(b - c), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.1e+74], 1.0, If[LessEqual[t, 1e+151], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e+281], 1.0, N[(1.0 / N[(N[(N[(x + y), $MachinePrecision] + N[(N[(N[(0.8333333333333334 + a), $MachinePrecision] * N[(y + N[(N[(c * y), $MachinePrecision] * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(c * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if t < 1.7e-5

   1. Initial program 94.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 1.7e-5 < t < 4.1e74 or 1.00000000000000002e151 < t < 5.80000000000000019e281

   1. Initial program 94.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 4.1e74 < t < 1.00000000000000002e151

   1. Initial program 100.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if 5.80000000000000019e281 < t

   1. Initial program 84.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in t around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 13: 58.4% accurate, 2.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(0.8333333333333334 + a\right) + -0.6666666666666666 \cdot \frac{1}{t}\\ t_2 := \left(b - c\right) \cdot \left(b - c\right)\\ t_3 := \left(0.8333333333333334 + a\right) - 0.6666666666666666 \cdot \frac{1}{t}\\ \mathbf{if}\;b - c \leq -2 \cdot 10^{+257}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{t\_2}{t}}{t}\right)\right)}\\ \mathbf{elif}\;b - c \leq -1 \cdot 10^{+217}:\\ \;\;\;\;1\\ \mathbf{elif}\;b - c \leq -5 \cdot 10^{-206}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + c \cdot \left(2 \cdot \left(c \cdot \left(t\_3 \cdot t\_3\right) + t\_3\right)\right)\right)}\\ \mathbf{elif}\;b - c \leq 5 \cdot 10^{-48}:\\ \;\;\;\;\frac{x}{\left(x + y\right) + 2 \cdot \frac{y \cdot \left(\frac{z \cdot z}{t} - t\_2 \cdot \left(t\_1 \cdot t\_1\right)\right)}{b \cdot t\_1}}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (+ (+ 0.8333333333333334 a) (* -0.6666666666666666 (/ 1.0 t))))
        (t_2 (* (- b c) (- b c)))
        (t_3 (- (+ 0.8333333333333334 a) (* 0.6666666666666666 (/ 1.0 t)))))
   (if (<= (- b c) -2e+257)
     (/
      x
      (+
       x
       (*
        y
        (+
         1.0
         (-
          (/
           (+
            (* -1.3333333333333333 (- b c))
            (* -0.8888888888888888 (/ t_2 t)))
           t))))))
     (if (<= (- b c) -1e+217)
       1.0
       (if (<= (- b c) -5e-206)
         (/ x (+ x (* y (+ 1.0 (* c (* 2.0 (+ (* c (* t_3 t_3)) t_3)))))))
         (if (<= (- b c) 5e-48)
           (/
            x
            (+
             (+ x y)
             (*
              2.0
              (/ (* y (- (/ (* z z) t) (* t_2 (* t_1 t_1)))) (* b t_1)))))
           1.0))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double t_2 = (b - c) * (b - c);
	double t_3 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (t_2 / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= -5e-206) {
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_3 * t_3)) + t_3))))));
	} else if ((b - c) <= 5e-48) {
		tmp = x / ((x + y) + (2.0 * ((y * (((z * z) / t) - (t_2 * (t_1 * t_1)))) / (b * t_1))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = (0.8333333333333334d0 + a) + ((-0.6666666666666666d0) * (1.0d0 / t))
    t_2 = (b - c) * (b - c)
    t_3 = (0.8333333333333334d0 + a) - (0.6666666666666666d0 * (1.0d0 / t))
    if ((b - c) <= (-2d+257)) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (t_2 / t))) / t))))
    else if ((b - c) <= (-1d+217)) then
        tmp = 1.0d0
    else if ((b - c) <= (-5d-206)) then
        tmp = x / (x + (y * (1.0d0 + (c * (2.0d0 * ((c * (t_3 * t_3)) + t_3))))))
    else if ((b - c) <= 5d-48) then
        tmp = x / ((x + y) + (2.0d0 * ((y * (((z * z) / t) - (t_2 * (t_1 * t_1)))) / (b * t_1))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double t_2 = (b - c) * (b - c);
	double t_3 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (t_2 / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= -5e-206) {
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_3 * t_3)) + t_3))))));
	} else if ((b - c) <= 5e-48) {
		tmp = x / ((x + y) + (2.0 * ((y * (((z * z) / t) - (t_2 * (t_1 * t_1)))) / (b * t_1))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t))
	t_2 = (b - c) * (b - c)
	t_3 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t))
	tmp = 0
	if (b - c) <= -2e+257:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (t_2 / t))) / t))))
	elif (b - c) <= -1e+217:
		tmp = 1.0
	elif (b - c) <= -5e-206:
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_3 * t_3)) + t_3))))))
	elif (b - c) <= 5e-48:
		tmp = x / ((x + y) + (2.0 * ((y * (((z * z) / t) - (t_2 * (t_1 * t_1)))) / (b * t_1))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(0.8333333333333334 + a) + Float64(-0.6666666666666666 * Float64(1.0 / t)))
	t_2 = Float64(Float64(b - c) * Float64(b - c))
	t_3 = Float64(Float64(0.8333333333333334 + a) - Float64(0.6666666666666666 * Float64(1.0 / t)))
	tmp = 0.0
	if (Float64(b - c) <= -2e+257)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(t_2 / t))) / t))))));
	elseif (Float64(b - c) <= -1e+217)
		tmp = 1.0;
	elseif (Float64(b - c) <= -5e-206)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(c * Float64(2.0 * Float64(Float64(c * Float64(t_3 * t_3)) + t_3)))))));
	elseif (Float64(b - c) <= 5e-48)
		tmp = Float64(x / Float64(Float64(x + y) + Float64(2.0 * Float64(Float64(y * Float64(Float64(Float64(z * z) / t) - Float64(t_2 * Float64(t_1 * t_1)))) / Float64(b * t_1)))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	t_2 = (b - c) * (b - c);
	t_3 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	tmp = 0.0;
	if ((b - c) <= -2e+257)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (t_2 / t))) / t))));
	elseif ((b - c) <= -1e+217)
		tmp = 1.0;
	elseif ((b - c) <= -5e-206)
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_3 * t_3)) + t_3))))));
	elseif ((b - c) <= 5e-48)
		tmp = x / ((x + y) + (2.0 * ((y * (((z * z) / t) - (t_2 * (t_1 * t_1)))) / (b * t_1))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(0.8333333333333334 + a), $MachinePrecision] + N[(-0.6666666666666666 * N[(1.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(0.8333333333333334 + a), $MachinePrecision] - N[(0.6666666666666666 * N[(1.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b - c), $MachinePrecision], -2e+257], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(t$95$2 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], -1e+217], 1.0, If[LessEqual[N[(b - c), $MachinePrecision], -5e-206], N[(x / N[(x + N[(y * N[(1.0 + N[(c * N[(2.0 * N[(N[(c * N[(t$95$3 * t$95$3), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], 5e-48], N[(x / N[(N[(x + y), $MachinePrecision] + N[(2.0 * N[(N[(y * N[(N[(N[(z * z), $MachinePrecision] / t), $MachinePrecision] - N[(t$95$2 * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]]]]]]]

Derivation

1. Split input into 4 regimes

2. if (-.f64 b c) < -2.00000000000000006e257

   1. Initial program 89.5%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.00000000000000006e257 < (-.f64 b c) < -9.9999999999999996e216 or 4.9999999999999999e-48 < (-.f64 b c)

   1. Initial program 91.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -9.9999999999999996e216 < (-.f64 b c) < -5e-206

   1. Initial program 97.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -5e-206 < (-.f64 b c) < 4.9999999999999999e-48

   1. Initial program 100.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in b around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 14: 59.4% accurate, 3.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(0.8333333333333334 + a\right) - 0.6666666666666666 \cdot \frac{1}{t}\\ \mathbf{if}\;b - c \leq -2 \cdot 10^{+257}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{\left(b - c\right) \cdot \left(b - c\right)}{t}}{t}\right)\right)}\\ \mathbf{elif}\;b - c \leq -1 \cdot 10^{+217}:\\ \;\;\;\;1\\ \mathbf{elif}\;b - c \leq 5 \cdot 10^{-48}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + c \cdot \left(2 \cdot \left(c \cdot \left(t\_1 \cdot t\_1\right) + t\_1\right)\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (- (+ 0.8333333333333334 a) (* 0.6666666666666666 (/ 1.0 t)))))
   (if (<= (- b c) -2e+257)
     (/
      x
      (+
       x
       (*
        y
        (+
         1.0
         (-
          (/
           (+
            (* -1.3333333333333333 (- b c))
            (* -0.8888888888888888 (/ (* (- b c) (- b c)) t)))
           t))))))
     (if (<= (- b c) -1e+217)
       1.0
       (if (<= (- b c) 5e-48)
         (/ x (+ x (* y (+ 1.0 (* c (* 2.0 (+ (* c (* t_1 t_1)) t_1)))))))
         1.0)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= 5e-48) {
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_1 * t_1)) + t_1))))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (0.8333333333333334d0 + a) - (0.6666666666666666d0 * (1.0d0 / t))
    if ((b - c) <= (-2d+257)) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (((b - c) * (b - c)) / t))) / t))))
    else if ((b - c) <= (-1d+217)) then
        tmp = 1.0d0
    else if ((b - c) <= 5d-48) then
        tmp = x / (x + (y * (1.0d0 + (c * (2.0d0 * ((c * (t_1 * t_1)) + t_1))))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= 5e-48) {
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_1 * t_1)) + t_1))))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t))
	tmp = 0
	if (b - c) <= -2e+257:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))))
	elif (b - c) <= -1e+217:
		tmp = 1.0
	elif (b - c) <= 5e-48:
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_1 * t_1)) + t_1))))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(0.8333333333333334 + a) - Float64(0.6666666666666666 * Float64(1.0 / t)))
	tmp = 0.0
	if (Float64(b - c) <= -2e+257)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(Float64(Float64(b - c) * Float64(b - c)) / t))) / t))))));
	elseif (Float64(b - c) <= -1e+217)
		tmp = 1.0;
	elseif (Float64(b - c) <= 5e-48)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(c * Float64(2.0 * Float64(Float64(c * Float64(t_1 * t_1)) + t_1)))))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (0.8333333333333334 + a) - (0.6666666666666666 * (1.0 / t));
	tmp = 0.0;
	if ((b - c) <= -2e+257)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	elseif ((b - c) <= -1e+217)
		tmp = 1.0;
	elseif ((b - c) <= 5e-48)
		tmp = x / (x + (y * (1.0 + (c * (2.0 * ((c * (t_1 * t_1)) + t_1))))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(0.8333333333333334 + a), $MachinePrecision] - N[(0.6666666666666666 * N[(1.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b - c), $MachinePrecision], -2e+257], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], -1e+217], 1.0, If[LessEqual[N[(b - c), $MachinePrecision], 5e-48], N[(x / N[(x + N[(y * N[(1.0 + N[(c * N[(2.0 * N[(N[(c * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]]]]

Derivation

1. Split input into 3 regimes

2. if (-.f64 b c) < -2.00000000000000006e257

   1. Initial program 89.5%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.00000000000000006e257 < (-.f64 b c) < -9.9999999999999996e216 or 4.9999999999999999e-48 < (-.f64 b c)

   1. Initial program 91.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -9.9999999999999996e216 < (-.f64 b c) < 4.9999999999999999e-48

   1. Initial program 98.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 15: 57.8% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(0.8333333333333334 + a\right) + -0.6666666666666666 \cdot \frac{1}{t}\\ \mathbf{if}\;b - c \leq -2 \cdot 10^{+257}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{\left(b - c\right) \cdot \left(b - c\right)}{t}}{t}\right)\right)}\\ \mathbf{elif}\;b - c \leq -1 \cdot 10^{+217}:\\ \;\;\;\;1\\ \mathbf{elif}\;b - c \leq -2 \cdot 10^{-44}:\\ \;\;\;\;\frac{1}{1 + y \cdot \left(2 \cdot \frac{c \cdot \left(\left(1 + c \cdot t\_1\right) \cdot t\_1\right)}{x} + \frac{1}{x}\right)}\\ \mathbf{elif}\;b - c \leq 0.01:\\ \;\;\;\;\frac{x}{\left(x + y\right) + c \cdot \left(\left(c \cdot 0.8888888888888888\right) \cdot \frac{y}{t \cdot t}\right)}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (+ (+ 0.8333333333333334 a) (* -0.6666666666666666 (/ 1.0 t)))))
   (if (<= (- b c) -2e+257)
     (/
      x
      (+
       x
       (*
        y
        (+
         1.0
         (-
          (/
           (+
            (* -1.3333333333333333 (- b c))
            (* -0.8888888888888888 (/ (* (- b c) (- b c)) t)))
           t))))))
     (if (<= (- b c) -1e+217)
       1.0
       (if (<= (- b c) -2e-44)
         (/
          1.0
          (+
           1.0
           (* y (+ (* 2.0 (/ (* c (* (+ 1.0 (* c t_1)) t_1)) x)) (/ 1.0 x)))))
         (if (<= (- b c) 0.01)
           (/ x (+ (+ x y) (* c (* (* c 0.8888888888888888) (/ y (* t t))))))
           1.0))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= -2e-44) {
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	} else if ((b - c) <= 0.01) {
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (0.8333333333333334d0 + a) + ((-0.6666666666666666d0) * (1.0d0 / t))
    if ((b - c) <= (-2d+257)) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (((b - c) * (b - c)) / t))) / t))))
    else if ((b - c) <= (-1d+217)) then
        tmp = 1.0d0
    else if ((b - c) <= (-2d-44)) then
        tmp = 1.0d0 / (1.0d0 + (y * ((2.0d0 * ((c * ((1.0d0 + (c * t_1)) * t_1)) / x)) + (1.0d0 / x))))
    else if ((b - c) <= 0.01d0) then
        tmp = x / ((x + y) + (c * ((c * 0.8888888888888888d0) * (y / (t * t)))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	double tmp;
	if ((b - c) <= -2e+257) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -1e+217) {
		tmp = 1.0;
	} else if ((b - c) <= -2e-44) {
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	} else if ((b - c) <= 0.01) {
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t))
	tmp = 0
	if (b - c) <= -2e+257:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))))
	elif (b - c) <= -1e+217:
		tmp = 1.0
	elif (b - c) <= -2e-44:
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))))
	elif (b - c) <= 0.01:
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(0.8333333333333334 + a) + Float64(-0.6666666666666666 * Float64(1.0 / t)))
	tmp = 0.0
	if (Float64(b - c) <= -2e+257)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(Float64(Float64(b - c) * Float64(b - c)) / t))) / t))))));
	elseif (Float64(b - c) <= -1e+217)
		tmp = 1.0;
	elseif (Float64(b - c) <= -2e-44)
		tmp = Float64(1.0 / Float64(1.0 + Float64(y * Float64(Float64(2.0 * Float64(Float64(c * Float64(Float64(1.0 + Float64(c * t_1)) * t_1)) / x)) + Float64(1.0 / x)))));
	elseif (Float64(b - c) <= 0.01)
		tmp = Float64(x / Float64(Float64(x + y) + Float64(c * Float64(Float64(c * 0.8888888888888888) * Float64(y / Float64(t * t))))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (0.8333333333333334 + a) + (-0.6666666666666666 * (1.0 / t));
	tmp = 0.0;
	if ((b - c) <= -2e+257)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	elseif ((b - c) <= -1e+217)
		tmp = 1.0;
	elseif ((b - c) <= -2e-44)
		tmp = 1.0 / (1.0 + (y * ((2.0 * ((c * ((1.0 + (c * t_1)) * t_1)) / x)) + (1.0 / x))));
	elseif ((b - c) <= 0.01)
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(0.8333333333333334 + a), $MachinePrecision] + N[(-0.6666666666666666 * N[(1.0 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b - c), $MachinePrecision], -2e+257], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], -1e+217], 1.0, If[LessEqual[N[(b - c), $MachinePrecision], -2e-44], N[(1.0 / N[(1.0 + N[(y * N[(N[(2.0 * N[(N[(c * N[(N[(1.0 + N[(c * t$95$1), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] + N[(1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], 0.01], N[(x / N[(N[(x + y), $MachinePrecision] + N[(c * N[(N[(c * 0.8888888888888888), $MachinePrecision] * N[(y / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]]]]]

Derivation

1. Split input into 4 regimes

2. if (-.f64 b c) < -2.00000000000000006e257

   1. Initial program 89.5%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.00000000000000006e257 < (-.f64 b c) < -9.9999999999999996e216 or 0.0100000000000000002 < (-.f64 b c)

   1. Initial program 90.4%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -9.9999999999999996e216 < (-.f64 b c) < -1.99999999999999991e-44

   1. Initial program 96.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.99999999999999991e-44 < (-.f64 b c) < 0.0100000000000000002

   1. Initial program 99.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   13. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 16: 60.3% accurate, 4.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b - c \leq -5 \cdot 10^{+161}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{\left(b - c\right) \cdot \left(b - c\right)}{t}}{t}\right)\right)}\\ \mathbf{elif}\;b - c \leq -2 \cdot 10^{-9}:\\ \;\;\;\;\frac{1}{\frac{\left(x + y\right) + \left(\left(0.8333333333333334 + \left(a - \frac{0.6666666666666666}{t}\right)\right) \cdot \left(\frac{-0.6666666666666666 \cdot \left(c \cdot y\right) + \left(c \cdot t\right) \cdot \left(y \cdot \left(0.8333333333333334 + a\right)\right)}{t} + y\right)\right) \cdot \left(c \cdot 2\right)}{x}}\\ \mathbf{elif}\;b - c \leq 0.01:\\ \;\;\;\;\frac{x}{\left(x + y\right) + c \cdot \left(\left(c \cdot 0.8888888888888888\right) \cdot \frac{y}{t \cdot t}\right)}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= (- b c) -5e+161)
   (/
    x
    (+
     x
     (*
      y
      (+
       1.0
       (-
        (/
         (+
          (* -1.3333333333333333 (- b c))
          (* -0.8888888888888888 (/ (* (- b c) (- b c)) t)))
         t))))))
   (if (<= (- b c) -2e-9)
     (/
      1.0
      (/
       (+
        (+ x y)
        (*
         (*
          (+ 0.8333333333333334 (- a (/ 0.6666666666666666 t)))
          (+
           (/
            (+
             (* -0.6666666666666666 (* c y))
             (* (* c t) (* y (+ 0.8333333333333334 a))))
            t)
           y))
         (* c 2.0)))
       x))
     (if (<= (- b c) 0.01)
       (/ x (+ (+ x y) (* c (* (* c 0.8888888888888888) (/ y (* t t))))))
       1.0))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -5e+161) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -2e-9) {
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + (a - (0.6666666666666666 / t))) * ((((-0.6666666666666666 * (c * y)) + ((c * t) * (y * (0.8333333333333334 + a)))) / t) + y)) * (c * 2.0))) / x);
	} else if ((b - c) <= 0.01) {
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if ((b - c) <= (-5d+161)) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (((b - c) * (b - c)) / t))) / t))))
    else if ((b - c) <= (-2d-9)) then
        tmp = 1.0d0 / (((x + y) + (((0.8333333333333334d0 + (a - (0.6666666666666666d0 / t))) * (((((-0.6666666666666666d0) * (c * y)) + ((c * t) * (y * (0.8333333333333334d0 + a)))) / t) + y)) * (c * 2.0d0))) / x)
    else if ((b - c) <= 0.01d0) then
        tmp = x / ((x + y) + (c * ((c * 0.8888888888888888d0) * (y / (t * t)))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -5e+161) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else if ((b - c) <= -2e-9) {
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + (a - (0.6666666666666666 / t))) * ((((-0.6666666666666666 * (c * y)) + ((c * t) * (y * (0.8333333333333334 + a)))) / t) + y)) * (c * 2.0))) / x);
	} else if ((b - c) <= 0.01) {
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if (b - c) <= -5e+161:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))))
	elif (b - c) <= -2e-9:
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + (a - (0.6666666666666666 / t))) * ((((-0.6666666666666666 * (c * y)) + ((c * t) * (y * (0.8333333333333334 + a)))) / t) + y)) * (c * 2.0))) / x)
	elif (b - c) <= 0.01:
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (Float64(b - c) <= -5e+161)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(Float64(Float64(b - c) * Float64(b - c)) / t))) / t))))));
	elseif (Float64(b - c) <= -2e-9)
		tmp = Float64(1.0 / Float64(Float64(Float64(x + y) + Float64(Float64(Float64(0.8333333333333334 + Float64(a - Float64(0.6666666666666666 / t))) * Float64(Float64(Float64(Float64(-0.6666666666666666 * Float64(c * y)) + Float64(Float64(c * t) * Float64(y * Float64(0.8333333333333334 + a)))) / t) + y)) * Float64(c * 2.0))) / x));
	elseif (Float64(b - c) <= 0.01)
		tmp = Float64(x / Float64(Float64(x + y) + Float64(c * Float64(Float64(c * 0.8888888888888888) * Float64(y / Float64(t * t))))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if ((b - c) <= -5e+161)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	elseif ((b - c) <= -2e-9)
		tmp = 1.0 / (((x + y) + (((0.8333333333333334 + (a - (0.6666666666666666 / t))) * ((((-0.6666666666666666 * (c * y)) + ((c * t) * (y * (0.8333333333333334 + a)))) / t) + y)) * (c * 2.0))) / x);
	elseif ((b - c) <= 0.01)
		tmp = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(b - c), $MachinePrecision], -5e+161], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], -2e-9], N[(1.0 / N[(N[(N[(x + y), $MachinePrecision] + N[(N[(N[(0.8333333333333334 + N[(a - N[(0.6666666666666666 / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(-0.6666666666666666 * N[(c * y), $MachinePrecision]), $MachinePrecision] + N[(N[(c * t), $MachinePrecision] * N[(y * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] * N[(c * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b - c), $MachinePrecision], 0.01], N[(x / N[(N[(x + y), $MachinePrecision] + N[(c * N[(N[(c * 0.8888888888888888), $MachinePrecision] * N[(y / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]]]

Derivation

1. Split input into 4 regimes

2. if (-.f64 b c) < -4.9999999999999997e161

   1. Initial program 90.7%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -4.9999999999999997e161 < (-.f64 b c) < -2.00000000000000012e-9

   1. Initial program 100.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in t around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -2.00000000000000012e-9 < (-.f64 b c) < 0.0100000000000000002

   1. Initial program 99.9%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   13. Applied egg-rr 0

       \[\leadsto expr\]

   if 0.0100000000000000002 < (-.f64 b c)

   1. Initial program 89.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 17: 50.6% accurate, 6.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \left(0.8333333333333334 + a\right) \cdot \left(y + \left(c \cdot y\right) \cdot \left(0.8333333333333334 + a\right)\right)\\ \mathbf{if}\;t \leq -7.8 \cdot 10^{+97}:\\ \;\;\;\;\frac{x}{\left(x + y\right) + \left(2 \cdot c\right) \cdot t\_1}\\ \mathbf{elif}\;t \leq 1.06 \cdot 10^{+282}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{\left(x + y\right) + t\_1 \cdot \left(c \cdot 2\right)}{x}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (*
          (+ 0.8333333333333334 a)
          (+ y (* (* c y) (+ 0.8333333333333334 a))))))
   (if (<= t -7.8e+97)
     (/ x (+ (+ x y) (* (* 2.0 c) t_1)))
     (if (<= t 1.06e+282) 1.0 (/ 1.0 (/ (+ (+ x y) (* t_1 (* c 2.0))) x))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)));
	double tmp;
	if (t <= -7.8e+97) {
		tmp = x / ((x + y) + ((2.0 * c) * t_1));
	} else if (t <= 1.06e+282) {
		tmp = 1.0;
	} else {
		tmp = 1.0 / (((x + y) + (t_1 * (c * 2.0))) / x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (0.8333333333333334d0 + a) * (y + ((c * y) * (0.8333333333333334d0 + a)))
    if (t <= (-7.8d+97)) then
        tmp = x / ((x + y) + ((2.0d0 * c) * t_1))
    else if (t <= 1.06d+282) then
        tmp = 1.0d0
    else
        tmp = 1.0d0 / (((x + y) + (t_1 * (c * 2.0d0))) / x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = (0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)));
	double tmp;
	if (t <= -7.8e+97) {
		tmp = x / ((x + y) + ((2.0 * c) * t_1));
	} else if (t <= 1.06e+282) {
		tmp = 1.0;
	} else {
		tmp = 1.0 / (((x + y) + (t_1 * (c * 2.0))) / x);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = (0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)))
	tmp = 0
	if t <= -7.8e+97:
		tmp = x / ((x + y) + ((2.0 * c) * t_1))
	elif t <= 1.06e+282:
		tmp = 1.0
	else:
		tmp = 1.0 / (((x + y) + (t_1 * (c * 2.0))) / x)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(Float64(0.8333333333333334 + a) * Float64(y + Float64(Float64(c * y) * Float64(0.8333333333333334 + a))))
	tmp = 0.0
	if (t <= -7.8e+97)
		tmp = Float64(x / Float64(Float64(x + y) + Float64(Float64(2.0 * c) * t_1)));
	elseif (t <= 1.06e+282)
		tmp = 1.0;
	else
		tmp = Float64(1.0 / Float64(Float64(Float64(x + y) + Float64(t_1 * Float64(c * 2.0))) / x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = (0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a)));
	tmp = 0.0;
	if (t <= -7.8e+97)
		tmp = x / ((x + y) + ((2.0 * c) * t_1));
	elseif (t <= 1.06e+282)
		tmp = 1.0;
	else
		tmp = 1.0 / (((x + y) + (t_1 * (c * 2.0))) / x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(0.8333333333333334 + a), $MachinePrecision] * N[(y + N[(N[(c * y), $MachinePrecision] * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.8e+97], N[(x / N[(N[(x + y), $MachinePrecision] + N[(N[(2.0 * c), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.06e+282], 1.0, N[(1.0 / N[(N[(N[(x + y), $MachinePrecision] + N[(t$95$1 * N[(c * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if t < -7.7999999999999999e97

   1. Initial program 91.7%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in t around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -7.7999999999999999e97 < t < 1.05999999999999997e282

   1. Initial program 95.2%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.05999999999999997e282 < t

   1. Initial program 84.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in t around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 18: 58.7% accurate, 6.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b - c \leq -1 \cdot 10^{+154}:\\ \;\;\;\;\frac{x}{x + y \cdot \left(1 + \left(-\frac{-1.3333333333333333 \cdot \left(b - c\right) + -0.8888888888888888 \cdot \frac{\left(b - c\right) \cdot \left(b - c\right)}{t}}{t}\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= (- b c) -1e+154)
   (/
    x
    (+
     x
     (*
      y
      (+
       1.0
       (-
        (/
         (+
          (* -1.3333333333333333 (- b c))
          (* -0.8888888888888888 (/ (* (- b c) (- b c)) t)))
         t))))))
   1.0))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -1e+154) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if ((b - c) <= (-1d+154)) then
        tmp = x / (x + (y * (1.0d0 + -((((-1.3333333333333333d0) * (b - c)) + ((-0.8888888888888888d0) * (((b - c) * (b - c)) / t))) / t))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -1e+154) {
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if (b - c) <= -1e+154:
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (Float64(b - c) <= -1e+154)
		tmp = Float64(x / Float64(x + Float64(y * Float64(1.0 + Float64(-Float64(Float64(Float64(-1.3333333333333333 * Float64(b - c)) + Float64(-0.8888888888888888 * Float64(Float64(Float64(b - c) * Float64(b - c)) / t))) / t))))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if ((b - c) <= -1e+154)
		tmp = x / (x + (y * (1.0 + -(((-1.3333333333333333 * (b - c)) + (-0.8888888888888888 * (((b - c) * (b - c)) / t))) / t))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(b - c), $MachinePrecision], -1e+154], N[(x / N[(x + N[(y * N[(1.0 + (-N[(N[(N[(-1.3333333333333333 * N[(b - c), $MachinePrecision]), $MachinePrecision] + N[(-0.8888888888888888 * N[(N[(N[(b - c), $MachinePrecision] * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]

Derivation

1. Split input into 2 regimes

2. if (-.f64 b c) < -1.00000000000000004e154

   1. Initial program 91.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.00000000000000004e154 < (-.f64 b c)

   1. Initial program 95.2%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 19: 55.3% accurate, 6.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b - c \leq -2 \cdot 10^{+152}:\\ \;\;\;\;\frac{x}{\left(x + y\right) + c \cdot \left(2 \cdot \left(c \cdot \left(y \cdot \left(\left(0.8333333333333334 + a\right) \cdot \left(0.8333333333333334 + a\right)\right)\right) + y \cdot \left(0.8333333333333334 + a\right)\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= (- b c) -2e+152)
   (/
    x
    (+
     (+ x y)
     (*
      c
      (*
       2.0
       (+
        (* c (* y (* (+ 0.8333333333333334 a) (+ 0.8333333333333334 a))))
        (* y (+ 0.8333333333333334 a)))))))
   1.0))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -2e+152) {
		tmp = x / ((x + y) + (c * (2.0 * ((c * (y * ((0.8333333333333334 + a) * (0.8333333333333334 + a)))) + (y * (0.8333333333333334 + a))))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if ((b - c) <= (-2d+152)) then
        tmp = x / ((x + y) + (c * (2.0d0 * ((c * (y * ((0.8333333333333334d0 + a) * (0.8333333333333334d0 + a)))) + (y * (0.8333333333333334d0 + a))))))
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if ((b - c) <= -2e+152) {
		tmp = x / ((x + y) + (c * (2.0 * ((c * (y * ((0.8333333333333334 + a) * (0.8333333333333334 + a)))) + (y * (0.8333333333333334 + a))))));
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if (b - c) <= -2e+152:
		tmp = x / ((x + y) + (c * (2.0 * ((c * (y * ((0.8333333333333334 + a) * (0.8333333333333334 + a)))) + (y * (0.8333333333333334 + a))))))
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (Float64(b - c) <= -2e+152)
		tmp = Float64(x / Float64(Float64(x + y) + Float64(c * Float64(2.0 * Float64(Float64(c * Float64(y * Float64(Float64(0.8333333333333334 + a) * Float64(0.8333333333333334 + a)))) + Float64(y * Float64(0.8333333333333334 + a)))))));
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if ((b - c) <= -2e+152)
		tmp = x / ((x + y) + (c * (2.0 * ((c * (y * ((0.8333333333333334 + a) * (0.8333333333333334 + a)))) + (y * (0.8333333333333334 + a))))));
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(b - c), $MachinePrecision], -2e+152], N[(x / N[(N[(x + y), $MachinePrecision] + N[(c * N[(2.0 * N[(N[(c * N[(y * N[(N[(0.8333333333333334 + a), $MachinePrecision] * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1.0]

Derivation

1. Split input into 2 regimes

2. if (-.f64 b c) < -2.0000000000000001e152

   1. Initial program 91.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -2.0000000000000001e152 < (-.f64 b c)

   1. Initial program 95.1%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 20: 50.6% accurate, 7.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{\left(x + y\right) + \left(2 \cdot c\right) \cdot \left(\left(0.8333333333333334 + a\right) \cdot \left(y + \left(c \cdot y\right) \cdot \left(0.8333333333333334 + a\right)\right)\right)}\\ \mathbf{if}\;t \leq -7.8 \cdot 10^{+97}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t \leq 2.15 \cdot 10^{+282}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/
          x
          (+
           (+ x y)
           (*
            (* 2.0 c)
            (*
             (+ 0.8333333333333334 a)
             (+ y (* (* c y) (+ 0.8333333333333334 a)))))))))
   (if (<= t -7.8e+97) t_1 (if (<= t 2.15e+282) 1.0 t_1))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / ((x + y) + ((2.0 * c) * ((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a))))));
	double tmp;
	if (t <= -7.8e+97) {
		tmp = t_1;
	} else if (t <= 2.15e+282) {
		tmp = 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / ((x + y) + ((2.0d0 * c) * ((0.8333333333333334d0 + a) * (y + ((c * y) * (0.8333333333333334d0 + a))))))
    if (t <= (-7.8d+97)) then
        tmp = t_1
    else if (t <= 2.15d+282) then
        tmp = 1.0d0
    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 c) {
	double t_1 = x / ((x + y) + ((2.0 * c) * ((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a))))));
	double tmp;
	if (t <= -7.8e+97) {
		tmp = t_1;
	} else if (t <= 2.15e+282) {
		tmp = 1.0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / ((x + y) + ((2.0 * c) * ((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a))))))
	tmp = 0
	if t <= -7.8e+97:
		tmp = t_1
	elif t <= 2.15e+282:
		tmp = 1.0
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(Float64(x + y) + Float64(Float64(2.0 * c) * Float64(Float64(0.8333333333333334 + a) * Float64(y + Float64(Float64(c * y) * Float64(0.8333333333333334 + a)))))))
	tmp = 0.0
	if (t <= -7.8e+97)
		tmp = t_1;
	elseif (t <= 2.15e+282)
		tmp = 1.0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / ((x + y) + ((2.0 * c) * ((0.8333333333333334 + a) * (y + ((c * y) * (0.8333333333333334 + a))))));
	tmp = 0.0;
	if (t <= -7.8e+97)
		tmp = t_1;
	elseif (t <= 2.15e+282)
		tmp = 1.0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(N[(x + y), $MachinePrecision] + N[(N[(2.0 * c), $MachinePrecision] * N[(N[(0.8333333333333334 + a), $MachinePrecision] * N[(y + N[(N[(c * y), $MachinePrecision] * N[(0.8333333333333334 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.8e+97], t$95$1, If[LessEqual[t, 2.15e+282], 1.0, t$95$1]]]

Derivation

1. Split input into 2 regimes

2. if t < -7.7999999999999999e97 or 2.15e282 < t

   1. Initial program 88.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in t around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -7.7999999999999999e97 < t < 2.15e282

   1. Initial program 95.2%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 21: 48.8% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{\left(x + y\right) + c \cdot \left(\left(c \cdot 0.8888888888888888\right) \cdot \frac{y}{t \cdot t}\right)}\\ \mathbf{if}\;x \leq -9 \cdot 10^{+176}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;x \leq -7 \cdot 10^{-231}:\\ \;\;\;\;1\\ \mathbf{elif}\;x \leq 6.4 \cdot 10^{-189}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1
         (/ x (+ (+ x y) (* c (* (* c 0.8888888888888888) (/ y (* t t))))))))
   (if (<= x -9e+176)
     t_1
     (if (<= x -7e-231) 1.0 (if (<= x 6.4e-189) t_1 1.0)))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	double tmp;
	if (x <= -9e+176) {
		tmp = t_1;
	} else if (x <= -7e-231) {
		tmp = 1.0;
	} else if (x <= 6.4e-189) {
		tmp = t_1;
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / ((x + y) + (c * ((c * 0.8888888888888888d0) * (y / (t * t)))))
    if (x <= (-9d+176)) then
        tmp = t_1
    else if (x <= (-7d-231)) then
        tmp = 1.0d0
    else if (x <= 6.4d-189) then
        tmp = t_1
    else
        tmp = 1.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	double tmp;
	if (x <= -9e+176) {
		tmp = t_1;
	} else if (x <= -7e-231) {
		tmp = 1.0;
	} else if (x <= 6.4e-189) {
		tmp = t_1;
	} else {
		tmp = 1.0;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))))
	tmp = 0
	if x <= -9e+176:
		tmp = t_1
	elif x <= -7e-231:
		tmp = 1.0
	elif x <= 6.4e-189:
		tmp = t_1
	else:
		tmp = 1.0
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(x / Float64(Float64(x + y) + Float64(c * Float64(Float64(c * 0.8888888888888888) * Float64(y / Float64(t * t))))))
	tmp = 0.0
	if (x <= -9e+176)
		tmp = t_1;
	elseif (x <= -7e-231)
		tmp = 1.0;
	elseif (x <= 6.4e-189)
		tmp = t_1;
	else
		tmp = 1.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = x / ((x + y) + (c * ((c * 0.8888888888888888) * (y / (t * t)))));
	tmp = 0.0;
	if (x <= -9e+176)
		tmp = t_1;
	elseif (x <= -7e-231)
		tmp = 1.0;
	elseif (x <= 6.4e-189)
		tmp = t_1;
	else
		tmp = 1.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(x / N[(N[(x + y), $MachinePrecision] + N[(c * N[(N[(c * 0.8888888888888888), $MachinePrecision] * N[(y / N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -9e+176], t$95$1, If[LessEqual[x, -7e-231], 1.0, If[LessEqual[x, 6.4e-189], t$95$1, 1.0]]]]

Derivation

1. Split input into 2 regimes

2. if x < -9.00000000000000007e176 or -7.0000000000000002e-231 < x < 6.4000000000000001e-189

   1. Initial program 91.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   13. Applied egg-rr 0

       \[\leadsto expr\]

   if -9.00000000000000007e176 < x < -7.0000000000000002e-231 or 6.4000000000000001e-189 < x

   1. Initial program 96.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 22: 50.3% accurate, 10.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq 4.2 \cdot 10^{+285}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{\left(x + y\right) + c \cdot \left(2 \cdot \left(\left(a \cdot a\right) \cdot \left(c \cdot y\right)\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t 4.2e+285) 1.0 (/ x (+ (+ x y) (* c (* 2.0 (* (* a a) (* c y))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 4.2e+285) {
		tmp = 1.0;
	} else {
		tmp = x / ((x + y) + (c * (2.0 * ((a * a) * (c * y)))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= 4.2d+285) then
        tmp = 1.0d0
    else
        tmp = x / ((x + y) + (c * (2.0d0 * ((a * a) * (c * y)))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 4.2e+285) {
		tmp = 1.0;
	} else {
		tmp = x / ((x + y) + (c * (2.0 * ((a * a) * (c * y)))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= 4.2e+285:
		tmp = 1.0
	else:
		tmp = x / ((x + y) + (c * (2.0 * ((a * a) * (c * y)))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 4.2e+285)
		tmp = 1.0;
	else
		tmp = Float64(x / Float64(Float64(x + y) + Float64(c * Float64(2.0 * Float64(Float64(a * a) * Float64(c * y))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= 4.2e+285)
		tmp = 1.0;
	else
		tmp = x / ((x + y) + (c * (2.0 * ((a * a) * (c * y)))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 4.2e+285], 1.0, N[(x / N[(N[(x + y), $MachinePrecision] + N[(c * N[(2.0 * N[(N[(a * a), $MachinePrecision] * N[(c * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < 4.2e285

   1. Initial program 95.1%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 4.2e285 < t

   1. Initial program 80.0%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 23: 50.5% accurate, 11.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq 3 \cdot 10^{+161}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{x + \left(y + 1.3333333333333333 \cdot \frac{y \cdot \left(b - c\right)}{t}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= z 3e+161)
   1.0
   (/ x (+ x (+ y (* 1.3333333333333333 (/ (* y (- b c)) t)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (z <= 3e+161) {
		tmp = 1.0;
	} else {
		tmp = x / (x + (y + (1.3333333333333333 * ((y * (b - c)) / t))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (z <= 3d+161) then
        tmp = 1.0d0
    else
        tmp = x / (x + (y + (1.3333333333333333d0 * ((y * (b - c)) / 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 c) {
	double tmp;
	if (z <= 3e+161) {
		tmp = 1.0;
	} else {
		tmp = x / (x + (y + (1.3333333333333333 * ((y * (b - c)) / t))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if z <= 3e+161:
		tmp = 1.0
	else:
		tmp = x / (x + (y + (1.3333333333333333 * ((y * (b - c)) / t))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (z <= 3e+161)
		tmp = 1.0;
	else
		tmp = Float64(x / Float64(x + Float64(y + Float64(1.3333333333333333 * Float64(Float64(y * Float64(b - c)) / t)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (z <= 3e+161)
		tmp = 1.0;
	else
		tmp = x / (x + (y + (1.3333333333333333 * ((y * (b - c)) / t))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[z, 3e+161], 1.0, N[(x / N[(x + N[(y + N[(1.3333333333333333 * N[(N[(y * N[(b - c), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < 3.00000000000000011e161

   1. Initial program 95.6%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 3.00000000000000011e161 < z

   1. Initial program 86.3%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in t around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in t around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 24: 49.9% accurate, 12.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq 6.4 \cdot 10^{+295}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{2 \cdot \left(\left(a \cdot a\right) \cdot \left(\left(c \cdot c\right) \cdot y\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t 6.4e+295) 1.0 (/ x (* 2.0 (* (* a a) (* (* c c) y))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 6.4e+295) {
		tmp = 1.0;
	} else {
		tmp = x / (2.0 * ((a * a) * ((c * c) * y)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= 6.4d+295) then
        tmp = 1.0d0
    else
        tmp = x / (2.0d0 * ((a * a) * ((c * c) * y)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 6.4e+295) {
		tmp = 1.0;
	} else {
		tmp = x / (2.0 * ((a * a) * ((c * c) * y)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= 6.4e+295:
		tmp = 1.0
	else:
		tmp = x / (2.0 * ((a * a) * ((c * c) * y)))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 6.4e+295)
		tmp = 1.0;
	else
		tmp = Float64(x / Float64(2.0 * Float64(Float64(a * a) * Float64(Float64(c * c) * y))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= 6.4e+295)
		tmp = 1.0;
	else
		tmp = x / (2.0 * ((a * a) * ((c * c) * y)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 6.4e+295], 1.0, N[(x / N[(2.0 * N[(N[(a * a), $MachinePrecision] * N[(N[(c * c), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < 6.40000000000000043e295

   1. Initial program 94.7%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 6.40000000000000043e295 < t

   1. Initial program 87.5%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in a around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 25: 50.3% accurate, 12.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t \leq 3.6 \cdot 10^{+297}:\\ \;\;\;\;1\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{x \cdot x - y \cdot y} \cdot \left(x - y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (if (<= t 3.6e+297) 1.0 (* (/ x (- (* x x) (* y y))) (- x y))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 3.6e+297) {
		tmp = 1.0;
	} else {
		tmp = (x / ((x * x) - (y * y))) * (x - y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: tmp
    if (t <= 3.6d+297) then
        tmp = 1.0d0
    else
        tmp = (x / ((x * x) - (y * y))) * (x - y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double tmp;
	if (t <= 3.6e+297) {
		tmp = 1.0;
	} else {
		tmp = (x / ((x * x) - (y * y))) * (x - y);
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	tmp = 0
	if t <= 3.6e+297:
		tmp = 1.0
	else:
		tmp = (x / ((x * x) - (y * y))) * (x - y)
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	tmp = 0.0
	if (t <= 3.6e+297)
		tmp = 1.0;
	else
		tmp = Float64(Float64(x / Float64(Float64(x * x) - Float64(y * y))) * Float64(x - y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	tmp = 0.0;
	if (t <= 3.6e+297)
		tmp = 1.0;
	else
		tmp = (x / ((x * x) - (y * y))) * (x - y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[t, 3.6e+297], 1.0, N[(N[(x / N[(N[(x * x), $MachinePrecision] - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t < 3.5999999999999997e297

   1. Initial program 94.8%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 3.5999999999999997e297 < t

   1. Initial program 85.7%

      \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in c around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 26: 50.5% accurate, 231.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    code = 1.0d0
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 94.5%

   \[\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{z \cdot \sqrt{t + a}}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in x around inf 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]
8. Add Preprocessing

Developer Target 1: 95.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := z \cdot \sqrt{t + a}\\ t_2 := a - \frac{5}{6}\\ \mathbf{if}\;t < -2.118326644891581 \cdot 10^{-50}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\left(a \cdot c + 0.8333333333333334 \cdot c\right) - a \cdot b\right)}}\\ \mathbf{elif}\;t < 5.196588770651547 \cdot 10^{-123}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \frac{t\_1 \cdot \left(\left(3 \cdot t\right) \cdot t\_2\right) - \left(\left(\frac{5}{6} + a\right) \cdot \left(3 \cdot t\right) - 2\right) \cdot \left(t\_2 \cdot \left(\left(b - c\right) \cdot t\right)\right)}{\left(\left(t \cdot t\right) \cdot 3\right) \cdot t\_2}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{x + y \cdot e^{2 \cdot \left(\frac{t\_1}{t} - \left(b - c\right) \cdot \left(\left(a + \frac{5}{6}\right) - \frac{2}{t \cdot 3}\right)\right)}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c)
 :precision binary64
 (let* ((t_1 (* z (sqrt (+ t a)))) (t_2 (- a (/ 5.0 6.0))))
   (if (< t -2.118326644891581e-50)
     (/
      x
      (+
       x
       (* y (exp (* 2.0 (- (+ (* a c) (* 0.8333333333333334 c)) (* a b)))))))
     (if (< t 5.196588770651547e-123)
       (/
        x
        (+
         x
         (*
          y
          (exp
           (*
            2.0
            (/
             (-
              (* t_1 (* (* 3.0 t) t_2))
              (*
               (- (* (+ (/ 5.0 6.0) a) (* 3.0 t)) 2.0)
               (* t_2 (* (- b c) t))))
             (* (* (* t t) 3.0) t_2)))))))
       (/
        x
        (+
         x
         (*
          y
          (exp
           (*
            2.0
            (-
             (/ t_1 t)
             (* (- b c) (- (+ a (/ 5.0 6.0)) (/ 2.0 (* t 3.0))))))))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = z * sqrt((t + a));
	double t_2 = a - (5.0 / 6.0);
	double tmp;
	if (t < -2.118326644891581e-50) {
		tmp = x / (x + (y * exp((2.0 * (((a * c) + (0.8333333333333334 * c)) - (a * b))))));
	} else if (t < 5.196588770651547e-123) {
		tmp = x / (x + (y * exp((2.0 * (((t_1 * ((3.0 * t) * t_2)) - (((((5.0 / 6.0) + a) * (3.0 * t)) - 2.0) * (t_2 * ((b - c) * t)))) / (((t * t) * 3.0) * t_2))))));
	} else {
		tmp = x / (x + (y * exp((2.0 * ((t_1 / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c)
    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), intent (in) :: c
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = z * sqrt((t + a))
    t_2 = a - (5.0d0 / 6.0d0)
    if (t < (-2.118326644891581d-50)) then
        tmp = x / (x + (y * exp((2.0d0 * (((a * c) + (0.8333333333333334d0 * c)) - (a * b))))))
    else if (t < 5.196588770651547d-123) then
        tmp = x / (x + (y * exp((2.0d0 * (((t_1 * ((3.0d0 * t) * t_2)) - (((((5.0d0 / 6.0d0) + a) * (3.0d0 * t)) - 2.0d0) * (t_2 * ((b - c) * t)))) / (((t * t) * 3.0d0) * t_2))))))
    else
        tmp = x / (x + (y * exp((2.0d0 * ((t_1 / t) - ((b - c) * ((a + (5.0d0 / 6.0d0)) - (2.0d0 / (t * 3.0d0)))))))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c) {
	double t_1 = z * Math.sqrt((t + a));
	double t_2 = a - (5.0 / 6.0);
	double tmp;
	if (t < -2.118326644891581e-50) {
		tmp = x / (x + (y * Math.exp((2.0 * (((a * c) + (0.8333333333333334 * c)) - (a * b))))));
	} else if (t < 5.196588770651547e-123) {
		tmp = x / (x + (y * Math.exp((2.0 * (((t_1 * ((3.0 * t) * t_2)) - (((((5.0 / 6.0) + a) * (3.0 * t)) - 2.0) * (t_2 * ((b - c) * t)))) / (((t * t) * 3.0) * t_2))))));
	} else {
		tmp = x / (x + (y * Math.exp((2.0 * ((t_1 / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c):
	t_1 = z * math.sqrt((t + a))
	t_2 = a - (5.0 / 6.0)
	tmp = 0
	if t < -2.118326644891581e-50:
		tmp = x / (x + (y * math.exp((2.0 * (((a * c) + (0.8333333333333334 * c)) - (a * b))))))
	elif t < 5.196588770651547e-123:
		tmp = x / (x + (y * math.exp((2.0 * (((t_1 * ((3.0 * t) * t_2)) - (((((5.0 / 6.0) + a) * (3.0 * t)) - 2.0) * (t_2 * ((b - c) * t)))) / (((t * t) * 3.0) * t_2))))))
	else:
		tmp = x / (x + (y * math.exp((2.0 * ((t_1 / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))))
	return tmp

Julia

function code(x, y, z, t, a, b, c)
	t_1 = Float64(z * sqrt(Float64(t + a)))
	t_2 = Float64(a - Float64(5.0 / 6.0))
	tmp = 0.0
	if (t < -2.118326644891581e-50)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(Float64(a * c) + Float64(0.8333333333333334 * c)) - Float64(a * b)))))));
	elseif (t < 5.196588770651547e-123)
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(Float64(t_1 * Float64(Float64(3.0 * t) * t_2)) - Float64(Float64(Float64(Float64(Float64(5.0 / 6.0) + a) * Float64(3.0 * t)) - 2.0) * Float64(t_2 * Float64(Float64(b - c) * t)))) / Float64(Float64(Float64(t * t) * 3.0) * t_2)))))));
	else
		tmp = Float64(x / Float64(x + Float64(y * exp(Float64(2.0 * Float64(Float64(t_1 / t) - Float64(Float64(b - c) * Float64(Float64(a + Float64(5.0 / 6.0)) - Float64(2.0 / Float64(t * 3.0))))))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c)
	t_1 = z * sqrt((t + a));
	t_2 = a - (5.0 / 6.0);
	tmp = 0.0;
	if (t < -2.118326644891581e-50)
		tmp = x / (x + (y * exp((2.0 * (((a * c) + (0.8333333333333334 * c)) - (a * b))))));
	elseif (t < 5.196588770651547e-123)
		tmp = x / (x + (y * exp((2.0 * (((t_1 * ((3.0 * t) * t_2)) - (((((5.0 / 6.0) + a) * (3.0 * t)) - 2.0) * (t_2 * ((b - c) * t)))) / (((t * t) * 3.0) * t_2))))));
	else
		tmp = x / (x + (y * exp((2.0 * ((t_1 / t) - ((b - c) * ((a + (5.0 / 6.0)) - (2.0 / (t * 3.0)))))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(z * N[Sqrt[N[(t + a), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a - N[(5.0 / 6.0), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -2.118326644891581e-50], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[(a * c), $MachinePrecision] + N[(0.8333333333333334 * c), $MachinePrecision]), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Less[t, 5.196588770651547e-123], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(N[(t$95$1 * N[(N[(3.0 * t), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(N[(N[(5.0 / 6.0), $MachinePrecision] + a), $MachinePrecision] * N[(3.0 * t), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision] * N[(t$95$2 * N[(N[(b - c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(t * t), $MachinePrecision] * 3.0), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(x + N[(y * N[Exp[N[(2.0 * N[(N[(t$95$1 / t), $MachinePrecision] - N[(N[(b - c), $MachinePrecision] * N[(N[(a + N[(5.0 / 6.0), $MachinePrecision]), $MachinePrecision] - N[(2.0 / N[(t * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Reproduce

herbie shell --seed 2024111 
(FPCore (x y z t a b c)
  :name "Numeric.SpecFunctions:invIncompleteBetaWorker from math-functions-0.1.5.2, I"
  :precision binary64

  :alt
  (! :herbie-platform default (if (< t -2118326644891581/100000000000000000000000000000000000000000000000000000000000000000) (/ x (+ x (* y (exp (* 2 (- (+ (* a c) (* 4166666666666667/5000000000000000 c)) (* a b))))))) (if (< t 5196588770651547/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (/ x (+ x (* y (exp (* 2 (/ (- (* (* z (sqrt (+ t a))) (* (* 3 t) (- a (/ 5 6)))) (* (- (* (+ (/ 5 6) a) (* 3 t)) 2) (* (- a (/ 5 6)) (* (- b c) t)))) (* (* (* t t) 3) (- a (/ 5 6))))))))) (/ x (+ x (* y (exp (* 2 (- (/ (* z (sqrt (+ t a))) t) (* (- b c) (- (+ a (/ 5 6)) (/ 2 (* t 3)))))))))))))

  (/ x (+ x (* y (exp (* 2.0 (- (/ (* z (sqrt (+ t a))) t) (* (- b c) (- (+ a (/ 5.0 6.0)) (/ 2.0 (* t 3.0)))))))))))