Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2, C

Percentage Accurate: 58.1% → 98.4%

Time: 27.6s

Alternatives: 27

Speedup: 2.8×

Specification

Math

\[\begin{array}{l} \\ \frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (/
  (*
   (- x 2.0)
   (+
    (*
     (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y)
     x)
    z))
  (+
   (* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x)
   47.066876606)))

C

double code(double x, double y, double z) {
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((x - 2.0d0) * ((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
end function

Java

public static double code(double x, double y, double z) {
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}

Python

def code(x, y, z):
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]

Initial Program: 58.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (/
  (*
   (- x 2.0)
   (+
    (*
     (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y)
     x)
    z))
  (+
   (* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x)
   47.066876606)))

C

double code(double x, double y, double z) {
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((x - 2.0d0) * ((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
end function

Java

public static double code(double x, double y, double z) {
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
}

Python

def code(x, y, z):
	return ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]

Alternative 1: 98.4% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(263.505074721 + x \cdot \left(x + 43.3400022514\right)\right)\right)\\ \mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \leq 10^{+294}:\\ \;\;\;\;\mathsf{fma}\left(\frac{1}{t\_0} \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right), x \cdot \left(x + -2\right), \frac{z \cdot \left(x + -2\right)}{t\_0}\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (+
          47.066876606
          (*
           x
           (+
            313.399215894
            (* x (+ 263.505074721 (* x (+ x 43.3400022514)))))))))
   (if (<=
        (/
         (*
          (- x 2.0)
          (+
           (*
            (+
             (*
              (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416)
              x)
             y)
            x)
           z))
         (+
          (*
           (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
           x)
          47.066876606))
        1e+294)
     (fma
      (*
       (/ 1.0 t_0)
       (+
        y
        (* x (+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))))
      (* x (+ x -2.0))
      (/ (* z (+ x -2.0)) t_0))
     (*
      (+ x -2.0)
      (+
       4.16438922228
       (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x))))))))

C

double code(double x, double y, double z) {
	double t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	double tmp;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294) {
		tmp = fma(((1.0 / t_0) * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))), (x * (x + -2.0)), ((z * (x + -2.0)) / t_0));
	} else {
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	}
	return tmp;
}

Julia

function code(x, y, z)
	t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(263.505074721 + Float64(x * Float64(x + 43.3400022514)))))))
	tmp = 0.0
	if (Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294)
		tmp = fma(Float64(Float64(1.0 / t_0) * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))))), Float64(x * Float64(x + -2.0)), Float64(Float64(z * Float64(x + -2.0)) / t_0));
	else
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))));
	end
	return tmp
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(263.505074721 + N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], 1e+294], N[(N[(N[(1.0 / t$95$0), $MachinePrecision] * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * N[(x + -2.0), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(x + -2.0), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 1.00000000000000007e294

   1. Initial program 96.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.00000000000000007e294 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64)))

   1. Initial program 0.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

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

Alternative 2: 98.8% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(263.505074721 + x \cdot \left(x + 43.3400022514\right)\right)\right)\\ t_1 := \frac{z}{t\_0} + x \cdot \left(\frac{1}{t\_0} \cdot \left(y + x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)\right)\right)\\ \mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \leq 10^{+294}:\\ \;\;\;\;t\_1 \cdot x + t\_1 \cdot -2\\ \mathbf{else}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (+
          47.066876606
          (*
           x
           (+
            313.399215894
            (* x (+ 263.505074721 (* x (+ x 43.3400022514))))))))
        (t_1
         (+
          (/ z t_0)
          (*
           x
           (*
            (/ 1.0 t_0)
            (+
             y
             (*
              x
              (+
               137.519416416
               (* x (+ 78.6994924154 (* x 4.16438922228)))))))))))
   (if (<=
        (/
         (*
          (- x 2.0)
          (+
           (*
            (+
             (*
              (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416)
              x)
             y)
            x)
           z))
         (+
          (*
           (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
           x)
          47.066876606))
        1e+294)
     (+ (* t_1 x) (* t_1 -2.0))
     (*
      (+ x -2.0)
      (+
       4.16438922228
       (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x))))))))

C

double code(double x, double y, double z) {
	double t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	double t_1 = (z / t_0) + (x * ((1.0 / t_0) * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))));
	double tmp;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294) {
		tmp = (t_1 * x) + (t_1 * -2.0);
	} else {
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = 47.066876606d0 + (x * (313.399215894d0 + (x * (263.505074721d0 + (x * (x + 43.3400022514d0))))))
    t_1 = (z / t_0) + (x * ((1.0d0 / t_0) * (y + (x * (137.519416416d0 + (x * (78.6994924154d0 + (x * 4.16438922228d0))))))))
    if ((((x - 2.0d0) * ((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)) <= 1d+294) then
        tmp = (t_1 * x) + (t_1 * (-2.0d0))
    else
        tmp = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	double t_1 = (z / t_0) + (x * ((1.0 / t_0) * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))));
	double tmp;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294) {
		tmp = (t_1 * x) + (t_1 * -2.0);
	} else {
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))
	t_1 = (z / t_0) + (x * ((1.0 / t_0) * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))))
	tmp = 0
	if (((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294:
		tmp = (t_1 * x) + (t_1 * -2.0)
	else:
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(263.505074721 + Float64(x * Float64(x + 43.3400022514)))))))
	t_1 = Float64(Float64(z / t_0) + Float64(x * Float64(Float64(1.0 / t_0) * Float64(y + Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228)))))))))
	tmp = 0.0
	if (Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294)
		tmp = Float64(Float64(t_1 * x) + Float64(t_1 * -2.0));
	else
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	t_1 = (z / t_0) + (x * ((1.0 / t_0) * (y + (x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))))));
	tmp = 0.0;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294)
		tmp = (t_1 * x) + (t_1 * -2.0);
	else
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(263.505074721 + N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(z / t$95$0), $MachinePrecision] + N[(x * N[(N[(1.0 / t$95$0), $MachinePrecision] * N[(y + N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], 1e+294], N[(N[(t$95$1 * x), $MachinePrecision] + N[(t$95$1 * -2.0), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 1.00000000000000007e294

   1. Initial program 96.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.00000000000000007e294 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64)))

   1. Initial program 0.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

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

Alternative 3: 99.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(263.505074721 + x \cdot \left(x + 43.3400022514\right)\right)\right)\\ \mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \leq \infty:\\ \;\;\;\;\left(x + -2\right) \cdot \left(\frac{z}{t\_0} + x \cdot \left(\frac{y}{t\_0} + \frac{x \cdot \left(137.519416416 + x \cdot \left(78.6994924154 + x \cdot 4.16438922228\right)\right)}{t\_0}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 - \frac{101.7851458539211 - \frac{3451.550173699799 - \frac{124074.40615218398 - y}{x}}{x}}{x}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (+
          47.066876606
          (*
           x
           (+
            313.399215894
            (* x (+ 263.505074721 (* x (+ x 43.3400022514)))))))))
   (if (<=
        (/
         (*
          (- x 2.0)
          (+
           (*
            (+
             (*
              (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416)
              x)
             y)
            x)
           z))
         (+
          (*
           (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
           x)
          47.066876606))
        INFINITY)
     (*
      (+ x -2.0)
      (+
       (/ z t_0)
       (*
        x
        (+
         (/ y t_0)
         (/
          (* x (+ 137.519416416 (* x (+ 78.6994924154 (* x 4.16438922228)))))
          t_0)))))
     (*
      (+ x -2.0)
      (-
       4.16438922228
       (/
        (-
         101.7851458539211
         (/ (- 3451.550173699799 (/ (- 124074.40615218398 y) x)) x))
        x))))))

C

double code(double x, double y, double z) {
	double t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	double tmp;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= ((double) INFINITY)) {
		tmp = (x + -2.0) * ((z / t_0) + (x * ((y / t_0) + ((x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))) / t_0))));
	} else {
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	}
	return tmp;
}

Java

public static double code(double x, double y, double z) {
	double t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	double tmp;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= Double.POSITIVE_INFINITY) {
		tmp = (x + -2.0) * ((z / t_0) + (x * ((y / t_0) + ((x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))) / t_0))));
	} else {
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))
	tmp = 0
	if (((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= math.inf:
		tmp = (x + -2.0) * ((z / t_0) + (x * ((y / t_0) + ((x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))) / t_0))))
	else:
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x))
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(263.505074721 + Float64(x * Float64(x + 43.3400022514)))))))
	tmp = 0.0
	if (Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= Inf)
		tmp = Float64(Float64(x + -2.0) * Float64(Float64(z / t_0) + Float64(x * Float64(Float64(y / t_0) + Float64(Float64(x * Float64(137.519416416 + Float64(x * Float64(78.6994924154 + Float64(x * 4.16438922228))))) / t_0)))));
	else
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 - Float64(Float64(101.7851458539211 - Float64(Float64(3451.550173699799 - Float64(Float64(124074.40615218398 - y) / x)) / x)) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = 47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))));
	tmp = 0.0;
	if ((((x - 2.0) * ((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= Inf)
		tmp = (x + -2.0) * ((z / t_0) + (x * ((y / t_0) + ((x * (137.519416416 + (x * (78.6994924154 + (x * 4.16438922228))))) / t_0))));
	else
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(263.505074721 + N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(z / t$95$0), $MachinePrecision] + N[(x * N[(N[(y / t$95$0), $MachinePrecision] + N[(N[(x * N[(137.519416416 + N[(x * N[(78.6994924154 + N[(x * 4.16438922228), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 - N[(N[(101.7851458539211 - N[(N[(3451.550173699799 - N[(N[(124074.40615218398 - y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < +inf.0

   1. Initial program 90.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if +inf.0 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64)))

   1. Initial program 0.0%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   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 4: 98.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot 4.16438922228 + 78.6994924154\\ \mathbf{if}\;\frac{\left(x - 2\right) \cdot \left(\left(\left(t\_0 \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \leq 10^{+294}:\\ \;\;\;\;\left(x + -2\right) \cdot \frac{x \cdot \left(x \cdot \left(x \cdot t\_0 + 137.519416416\right) + y\right) + z}{x \cdot \left(x \cdot \left(x \cdot \left(x + 43.3400022514\right) + 263.505074721\right) + 313.399215894\right) + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ (* x 4.16438922228) 78.6994924154)))
   (if (<=
        (/
         (* (- x 2.0) (+ (* (+ (* (+ (* t_0 x) 137.519416416) x) y) x) z))
         (+
          (*
           (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
           x)
          47.066876606))
        1e+294)
     (*
      (+ x -2.0)
      (/
       (+ (* x (+ (* x (+ (* x t_0) 137.519416416)) y)) z)
       (+
        (*
         x
         (+ (* x (+ (* x (+ x 43.3400022514)) 263.505074721)) 313.399215894))
        47.066876606)))
     (*
      (+ x -2.0)
      (+
       4.16438922228
       (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x))))))))

C

double code(double x, double y, double z) {
	double t_0 = (x * 4.16438922228) + 78.6994924154;
	double tmp;
	if ((((x - 2.0) * ((((((t_0 * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294) {
		tmp = (x + -2.0) * (((x * ((x * ((x * t_0) + 137.519416416)) + y)) + z) / ((x * ((x * ((x * (x + 43.3400022514)) + 263.505074721)) + 313.399215894)) + 47.066876606));
	} else {
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x * 4.16438922228d0) + 78.6994924154d0
    if ((((x - 2.0d0) * ((((((t_0 * x) + 137.519416416d0) * x) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)) <= 1d+294) then
        tmp = (x + (-2.0d0)) * (((x * ((x * ((x * t_0) + 137.519416416d0)) + y)) + z) / ((x * ((x * ((x * (x + 43.3400022514d0)) + 263.505074721d0)) + 313.399215894d0)) + 47.066876606d0))
    else
        tmp = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x * 4.16438922228) + 78.6994924154;
	double tmp;
	if ((((x - 2.0) * ((((((t_0 * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294) {
		tmp = (x + -2.0) * (((x * ((x * ((x * t_0) + 137.519416416)) + y)) + z) / ((x * ((x * ((x * (x + 43.3400022514)) + 263.505074721)) + 313.399215894)) + 47.066876606));
	} else {
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x * 4.16438922228) + 78.6994924154
	tmp = 0
	if (((x - 2.0) * ((((((t_0 * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294:
		tmp = (x + -2.0) * (((x * ((x * ((x * t_0) + 137.519416416)) + y)) + z) / ((x * ((x * ((x * (x + 43.3400022514)) + 263.505074721)) + 313.399215894)) + 47.066876606))
	else:
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x * 4.16438922228) + 78.6994924154)
	tmp = 0.0
	if (Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(Float64(Float64(t_0 * x) + 137.519416416) * x) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294)
		tmp = Float64(Float64(x + -2.0) * Float64(Float64(Float64(x * Float64(Float64(x * Float64(Float64(x * t_0) + 137.519416416)) + y)) + z) / Float64(Float64(x * Float64(Float64(x * Float64(Float64(x * Float64(x + 43.3400022514)) + 263.505074721)) + 313.399215894)) + 47.066876606)));
	else
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x * 4.16438922228) + 78.6994924154;
	tmp = 0.0;
	if ((((x - 2.0) * ((((((t_0 * x) + 137.519416416) * x) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)) <= 1e+294)
		tmp = (x + -2.0) * (((x * ((x * ((x * t_0) + 137.519416416)) + y)) + z) / ((x * ((x * ((x * (x + 43.3400022514)) + 263.505074721)) + 313.399215894)) + 47.066876606));
	else
		tmp = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(t$95$0 * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], 1e+294], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(N[(x * N[(N[(x * N[(N[(x * t$95$0), $MachinePrecision] + 137.519416416), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision] / N[(N[(x * N[(N[(x * N[(N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision] + 263.505074721), $MachinePrecision]), $MachinePrecision] + 313.399215894), $MachinePrecision]), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64))) < 1.00000000000000007e294

   1. Initial program 96.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   if 1.00000000000000007e294 < (/.f64 (*.f64 (-.f64 x #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x #s(literal 104109730557/25000000000 binary64)) #s(literal 393497462077/5000000000 binary64)) x) #s(literal 4297481763/31250000 binary64)) x) y) x) z)) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x #s(literal 216700011257/5000000000 binary64)) x) #s(literal 263505074721/1000000000 binary64)) x) #s(literal 156699607947/500000000 binary64)) x) #s(literal 23533438303/500000000 binary64)))

   1. Initial program 0.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

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

Alternative 5: 98.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -160000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot \left(137.519416416 + x \cdot 78.6994924154\right) + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -160000000.0)
     t_0
     (if (<= x 17000000000.0)
       (/
        (*
         (- x 2.0)
         (+ (* (+ (* x (+ 137.519416416 (* x 78.6994924154))) y) x) z))
        (+
         (*
          (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
          x)
         47.066876606))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -160000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = ((x - 2.0) * ((((x * (137.519416416 + (x * 78.6994924154))) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-160000000.0d0)) then
        tmp = t_0
    else if (x <= 17000000000.0d0) then
        tmp = ((x - 2.0d0) * ((((x * (137.519416416d0 + (x * 78.6994924154d0))) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -160000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = ((x - 2.0) * ((((x * (137.519416416 + (x * 78.6994924154))) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -160000000.0:
		tmp = t_0
	elif x <= 17000000000.0:
		tmp = ((x - 2.0) * ((((x * (137.519416416 + (x * 78.6994924154))) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -160000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * Float64(137.519416416 + Float64(x * 78.6994924154))) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -160000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = ((x - 2.0) * ((((x * (137.519416416 + (x * 78.6994924154))) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -160000000.0], t$95$0, If[LessEqual[x, 17000000000.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * N[(137.519416416 + N[(x * 78.6994924154), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -1.6e8 or 1.7e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.6e8 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 6: 98.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -9200000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 20000000000:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot 137.519416416 + y\right) \cdot x + z\right)}{\left(\left(263.505074721 + x \cdot \left(x + 43.3400022514\right)\right) \cdot \left(x \cdot x\right) + x \cdot 313.399215894\right) + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -9200000.0)
     t_0
     (if (<= x 20000000000.0)
       (/
        (* (- x 2.0) (+ (* (+ (* x 137.519416416) y) x) z))
        (+
         (+
          (* (+ 263.505074721 (* x (+ x 43.3400022514))) (* x x))
          (* x 313.399215894))
         47.066876606))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -9200000.0) {
		tmp = t_0;
	} else if (x <= 20000000000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((263.505074721 + (x * (x + 43.3400022514))) * (x * x)) + (x * 313.399215894)) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-9200000.0d0)) then
        tmp = t_0
    else if (x <= 20000000000.0d0) then
        tmp = ((x - 2.0d0) * ((((x * 137.519416416d0) + y) * x) + z)) / ((((263.505074721d0 + (x * (x + 43.3400022514d0))) * (x * x)) + (x * 313.399215894d0)) + 47.066876606d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -9200000.0) {
		tmp = t_0;
	} else if (x <= 20000000000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((263.505074721 + (x * (x + 43.3400022514))) * (x * x)) + (x * 313.399215894)) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -9200000.0:
		tmp = t_0
	elif x <= 20000000000.0:
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((263.505074721 + (x * (x + 43.3400022514))) * (x * x)) + (x * 313.399215894)) + 47.066876606)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -9200000.0)
		tmp = t_0;
	elseif (x <= 20000000000.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * 137.519416416) + y) * x) + z)) / Float64(Float64(Float64(Float64(263.505074721 + Float64(x * Float64(x + 43.3400022514))) * Float64(x * x)) + Float64(x * 313.399215894)) + 47.066876606));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -9200000.0)
		tmp = t_0;
	elseif (x <= 20000000000.0)
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((263.505074721 + (x * (x + 43.3400022514))) * (x * x)) + (x * 313.399215894)) + 47.066876606);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -9200000.0], t$95$0, If[LessEqual[x, 20000000000.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * 137.519416416), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(263.505074721 + N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x * 313.399215894), $MachinePrecision]), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -9.2e6 or 2e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -9.2e6 < x < 2e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 7: 98.5% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -310000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot 137.519416416 + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -310000000.0)
     t_0
     (if (<= x 17000000000.0)
       (/
        (* (- x 2.0) (+ (* (+ (* x 137.519416416) y) x) z))
        (+
         (*
          (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894)
          x)
         47.066876606))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -310000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-310000000.0d0)) then
        tmp = t_0
    else if (x <= 17000000000.0d0) then
        tmp = ((x - 2.0d0) * ((((x * 137.519416416d0) + y) * x) + z)) / (((((((x + 43.3400022514d0) * x) + 263.505074721d0) * x) + 313.399215894d0) * x) + 47.066876606d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -310000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -310000000.0:
		tmp = t_0
	elif x <= 17000000000.0:
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -310000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * 137.519416416) + y) * x) + z)) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -310000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / (((((((x + 43.3400022514) * x) + 263.505074721) * x) + 313.399215894) * x) + 47.066876606);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -310000000.0], t$95$0, If[LessEqual[x, 17000000000.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * 137.519416416), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(x + 43.3400022514), $MachinePrecision] * x), $MachinePrecision] + 263.505074721), $MachinePrecision] * x), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -3.1e8 or 1.7e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -3.1e8 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 8: 98.4% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -150000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\left(z + x \cdot \left(y + x \cdot 137.519416416\right)\right) \cdot \frac{x + -2}{47.066876606 + x \cdot \left(313.399215894 + x \cdot \left(263.505074721 + x \cdot \left(x + 43.3400022514\right)\right)\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -150000000.0)
     t_0
     (if (<= x 17000000000.0)
       (*
        (+ z (* x (+ y (* x 137.519416416))))
        (/
         (+ x -2.0)
         (+
          47.066876606
          (*
           x
           (+
            313.399215894
            (* x (+ 263.505074721 (* x (+ x 43.3400022514)))))))))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -150000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = (z + (x * (y + (x * 137.519416416)))) * ((x + -2.0) / (47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-150000000.0d0)) then
        tmp = t_0
    else if (x <= 17000000000.0d0) then
        tmp = (z + (x * (y + (x * 137.519416416d0)))) * ((x + (-2.0d0)) / (47.066876606d0 + (x * (313.399215894d0 + (x * (263.505074721d0 + (x * (x + 43.3400022514d0))))))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -150000000.0) {
		tmp = t_0;
	} else if (x <= 17000000000.0) {
		tmp = (z + (x * (y + (x * 137.519416416)))) * ((x + -2.0) / (47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -150000000.0:
		tmp = t_0
	elif x <= 17000000000.0:
		tmp = (z + (x * (y + (x * 137.519416416)))) * ((x + -2.0) / (47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -150000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(z + Float64(x * Float64(y + Float64(x * 137.519416416)))) * Float64(Float64(x + -2.0) / Float64(47.066876606 + Float64(x * Float64(313.399215894 + Float64(x * Float64(263.505074721 + Float64(x * Float64(x + 43.3400022514)))))))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -150000000.0)
		tmp = t_0;
	elseif (x <= 17000000000.0)
		tmp = (z + (x * (y + (x * 137.519416416)))) * ((x + -2.0) / (47.066876606 + (x * (313.399215894 + (x * (263.505074721 + (x * (x + 43.3400022514))))))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -150000000.0], t$95$0, If[LessEqual[x, 17000000000.0], N[(N[(z + N[(x * N[(y + N[(x * 137.519416416), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 + N[(x * N[(313.399215894 + N[(x * N[(263.505074721 + N[(x * N[(x + 43.3400022514), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -1.5e8 or 1.7e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.5e8 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

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

Alternative 9: 97.8% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -47:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 43:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot 137.519416416 + y\right) \cdot x + z\right)}{\left(x \cdot 263.505074721 + 313.399215894\right) \cdot x + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -47.0)
     t_0
     (if (<= x 43.0)
       (/
        (* (- x 2.0) (+ (* (+ (* x 137.519416416) y) x) z))
        (+ (* (+ (* x 263.505074721) 313.399215894) x) 47.066876606))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -47.0) {
		tmp = t_0;
	} else if (x <= 43.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((x * 263.505074721) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-47.0d0)) then
        tmp = t_0
    else if (x <= 43.0d0) then
        tmp = ((x - 2.0d0) * ((((x * 137.519416416d0) + y) * x) + z)) / ((((x * 263.505074721d0) + 313.399215894d0) * x) + 47.066876606d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -47.0) {
		tmp = t_0;
	} else if (x <= 43.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((x * 263.505074721) + 313.399215894) * x) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -47.0:
		tmp = t_0
	elif x <= 43.0:
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((x * 263.505074721) + 313.399215894) * x) + 47.066876606)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -47.0)
		tmp = t_0;
	elseif (x <= 43.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * 137.519416416) + y) * x) + z)) / Float64(Float64(Float64(Float64(x * 263.505074721) + 313.399215894) * x) + 47.066876606));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -47.0)
		tmp = t_0;
	elseif (x <= 43.0)
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((((x * 263.505074721) + 313.399215894) * x) + 47.066876606);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -47.0], t$95$0, If[LessEqual[x, 43.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * 137.519416416), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(N[(x * 263.505074721), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -47 or 43 < x

   1. Initial program 15.6%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -47 < x < 43

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 10: 97.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{1 \cdot \left(y + \frac{z + -43.3400022514 \cdot y}{x}\right)}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -0.15:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 31:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot 137.519416416 + y\right) \cdot x + z\right)}{x \cdot 313.399215894 + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (+
           4.16438922228
           (/ (* 1.0 (+ y (/ (+ z (* -43.3400022514 y)) x))) (* x (* x x)))))))
   (if (<= x -0.15)
     t_0
     (if (<= x 31.0)
       (/
        (* (- x 2.0) (+ (* (+ (* x 137.519416416) y) x) z))
        (+ (* x 313.399215894) 47.066876606))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -0.15) {
		tmp = t_0;
	} else if (x <= 31.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + ((1.0d0 * (y + ((z + ((-43.3400022514d0) * y)) / x))) / (x * (x * x))))
    if (x <= (-0.15d0)) then
        tmp = t_0
    else if (x <= 31.0d0) then
        tmp = ((x - 2.0d0) * ((((x * 137.519416416d0) + y) * x) + z)) / ((x * 313.399215894d0) + 47.066876606d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	double tmp;
	if (x <= -0.15) {
		tmp = t_0;
	} else if (x <= 31.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))))
	tmp = 0
	if x <= -0.15:
		tmp = t_0
	elif x <= 31.0:
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(Float64(1.0 * Float64(y + Float64(Float64(z + Float64(-43.3400022514 * y)) / x))) / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -0.15)
		tmp = t_0;
	elseif (x <= 31.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * 137.519416416) + y) * x) + z)) / Float64(Float64(x * 313.399215894) + 47.066876606));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + ((1.0 * (y + ((z + (-43.3400022514 * y)) / x))) / (x * (x * x))));
	tmp = 0.0;
	if (x <= -0.15)
		tmp = t_0;
	elseif (x <= 31.0)
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(N[(1.0 * N[(y + N[(N[(z + N[(-43.3400022514 * y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -0.15], t$95$0, If[LessEqual[x, 31.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * 137.519416416), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(x * 313.399215894), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -0.149999999999999994 or 31 < x

   1. Initial program 15.6%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around -inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -0.149999999999999994 < x < 31

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

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

Alternative 11: 95.6% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.15:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 - \frac{101.7851458539211 - \frac{3451.550173699799 - \frac{124074.40615218398 - y}{x}}{x}}{x}\right)\\ \mathbf{elif}\;x \leq 80000:\\ \;\;\;\;\frac{\left(x - 2\right) \cdot \left(\left(x \cdot 137.519416416 + y\right) \cdot x + z\right)}{x \cdot 313.399215894 + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(4.16438922228 + \frac{y}{x \cdot \left(x \cdot x\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.15)
   (*
    (+ x -2.0)
    (-
     4.16438922228
     (/
      (-
       101.7851458539211
       (/ (- 3451.550173699799 (/ (- 124074.40615218398 y) x)) x))
      x)))
   (if (<= x 80000.0)
     (/
      (* (- x 2.0) (+ (* (+ (* x 137.519416416) y) x) z))
      (+ (* x 313.399215894) 47.066876606))
     (* (+ x -2.0) (+ 4.16438922228 (/ y (* x (* x x))))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.15) {
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	} else if (x <= 80000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	} else {
		tmp = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.15d0)) then
        tmp = (x + (-2.0d0)) * (4.16438922228d0 - ((101.7851458539211d0 - ((3451.550173699799d0 - ((124074.40615218398d0 - y) / x)) / x)) / x))
    else if (x <= 80000.0d0) then
        tmp = ((x - 2.0d0) * ((((x * 137.519416416d0) + y) * x) + z)) / ((x * 313.399215894d0) + 47.066876606d0)
    else
        tmp = (x + (-2.0d0)) * (4.16438922228d0 + (y / (x * (x * x))))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.15) {
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	} else if (x <= 80000.0) {
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	} else {
		tmp = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.15:
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x))
	elif x <= 80000.0:
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606)
	else:
		tmp = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.15)
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 - Float64(Float64(101.7851458539211 - Float64(Float64(3451.550173699799 - Float64(Float64(124074.40615218398 - y) / x)) / x)) / x)));
	elseif (x <= 80000.0)
		tmp = Float64(Float64(Float64(x - 2.0) * Float64(Float64(Float64(Float64(x * 137.519416416) + y) * x) + z)) / Float64(Float64(x * 313.399215894) + 47.066876606));
	else
		tmp = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(y / Float64(x * Float64(x * x)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.15)
		tmp = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	elseif (x <= 80000.0)
		tmp = ((x - 2.0) * ((((x * 137.519416416) + y) * x) + z)) / ((x * 313.399215894) + 47.066876606);
	else
		tmp = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.15], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 - N[(N[(101.7851458539211 - N[(N[(3451.550173699799 - N[(N[(124074.40615218398 - y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 80000.0], N[(N[(N[(x - 2.0), $MachinePrecision] * N[(N[(N[(N[(x * 137.519416416), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] / N[(N[(x * 313.399215894), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(y / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if x < -0.149999999999999994

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.149999999999999994 < x < 8e4

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 8e4 < x

   1. Initial program 9.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   13. Simplified 0

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

Alternative 12: 92.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 - \frac{101.7851458539211 - \frac{3451.550173699799 - \frac{124074.40615218398 - y}{x}}{x}}{x}\right)\\ \mathbf{if}\;x \leq -0.17:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 7.5:\\ \;\;\;\;\left(x + -2\right) \cdot \left(0.0212463641547976 \cdot z + x \cdot \left(0.0212463641547976 \cdot y + z \cdot -0.14147091005106402\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0
         (*
          (+ x -2.0)
          (-
           4.16438922228
           (/
            (-
             101.7851458539211
             (/ (- 3451.550173699799 (/ (- 124074.40615218398 y) x)) x))
            x)))))
   (if (<= x -0.17)
     t_0
     (if (<= x 7.5)
       (*
        (+ x -2.0)
        (+
         (* 0.0212463641547976 z)
         (* x (+ (* 0.0212463641547976 y) (* z -0.14147091005106402)))))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	double tmp;
	if (x <= -0.17) {
		tmp = t_0;
	} else if (x <= 7.5) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 - ((101.7851458539211d0 - ((3451.550173699799d0 - ((124074.40615218398d0 - y) / x)) / x)) / x))
    if (x <= (-0.17d0)) then
        tmp = t_0
    else if (x <= 7.5d0) then
        tmp = (x + (-2.0d0)) * ((0.0212463641547976d0 * z) + (x * ((0.0212463641547976d0 * y) + (z * (-0.14147091005106402d0)))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	double tmp;
	if (x <= -0.17) {
		tmp = t_0;
	} else if (x <= 7.5) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x))
	tmp = 0
	if x <= -0.17:
		tmp = t_0
	elif x <= 7.5:
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 - Float64(Float64(101.7851458539211 - Float64(Float64(3451.550173699799 - Float64(Float64(124074.40615218398 - y) / x)) / x)) / x)))
	tmp = 0.0
	if (x <= -0.17)
		tmp = t_0;
	elseif (x <= 7.5)
		tmp = Float64(Float64(x + -2.0) * Float64(Float64(0.0212463641547976 * z) + Float64(x * Float64(Float64(0.0212463641547976 * y) + Float64(z * -0.14147091005106402)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 - ((101.7851458539211 - ((3451.550173699799 - ((124074.40615218398 - y) / x)) / x)) / x));
	tmp = 0.0;
	if (x <= -0.17)
		tmp = t_0;
	elseif (x <= 7.5)
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 - N[(N[(101.7851458539211 - N[(N[(3451.550173699799 - N[(N[(124074.40615218398 - y), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -0.17], t$95$0, If[LessEqual[x, 7.5], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(0.0212463641547976 * z), $MachinePrecision] + N[(x * N[(N[(0.0212463641547976 * y), $MachinePrecision] + N[(z * -0.14147091005106402), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -0.170000000000000012 or 7.5 < x

   1. Initial program 15.6%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around -inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.170000000000000012 < x < 7.5

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 13: 79.6% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{y}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -5.5:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq -5.5 \cdot 10^{-80}:\\ \;\;\;\;\left(\left(x + -2\right) \cdot \left(y \cdot 0.0212463641547976 + z \cdot -0.14147091005106402\right)\right) \cdot x\\ \mathbf{elif}\;x \leq 0.00072:\\ \;\;\;\;\left(x + -2\right) \cdot \left(z \cdot \left(0.0212463641547976 + x \cdot -0.14147091005106402\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* (+ x -2.0) (+ 4.16438922228 (/ y (* x (* x x)))))))
   (if (<= x -5.5)
     t_0
     (if (<= x -5.5e-80)
       (*
        (* (+ x -2.0) (+ (* y 0.0212463641547976) (* z -0.14147091005106402)))
        x)
       (if (<= x 0.00072)
         (* (+ x -2.0) (* z (+ 0.0212463641547976 (* x -0.14147091005106402))))
         t_0)))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= -5.5e-80) {
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	} else if (x <= 0.00072) {
		tmp = (x + -2.0) * (z * (0.0212463641547976 + (x * -0.14147091005106402)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + (y / (x * (x * x))))
    if (x <= (-5.5d0)) then
        tmp = t_0
    else if (x <= (-5.5d-80)) then
        tmp = ((x + (-2.0d0)) * ((y * 0.0212463641547976d0) + (z * (-0.14147091005106402d0)))) * x
    else if (x <= 0.00072d0) then
        tmp = (x + (-2.0d0)) * (z * (0.0212463641547976d0 + (x * (-0.14147091005106402d0))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= -5.5e-80) {
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	} else if (x <= 0.00072) {
		tmp = (x + -2.0) * (z * (0.0212463641547976 + (x * -0.14147091005106402)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))))
	tmp = 0
	if x <= -5.5:
		tmp = t_0
	elif x <= -5.5e-80:
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x
	elif x <= 0.00072:
		tmp = (x + -2.0) * (z * (0.0212463641547976 + (x * -0.14147091005106402)))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(y / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= -5.5e-80)
		tmp = Float64(Float64(Float64(x + -2.0) * Float64(Float64(y * 0.0212463641547976) + Float64(z * -0.14147091005106402))) * x);
	elseif (x <= 0.00072)
		tmp = Float64(Float64(x + -2.0) * Float64(z * Float64(0.0212463641547976 + Float64(x * -0.14147091005106402))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	tmp = 0.0;
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= -5.5e-80)
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	elseif (x <= 0.00072)
		tmp = (x + -2.0) * (z * (0.0212463641547976 + (x * -0.14147091005106402)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(y / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.5], t$95$0, If[LessEqual[x, -5.5e-80], N[(N[(N[(x + -2.0), $MachinePrecision] * N[(N[(y * 0.0212463641547976), $MachinePrecision] + N[(z * -0.14147091005106402), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[x, 0.00072], N[(N[(x + -2.0), $MachinePrecision] * N[(z * N[(0.0212463641547976 + N[(x * -0.14147091005106402), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if x < -5.5 or 7.20000000000000045e-4 < x

   1. Initial program 16.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -5.5 < x < -5.4999999999999997e-80

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -5.4999999999999997e-80 < x < 7.20000000000000045e-4

   1. Initial program 99.8%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 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 3 regimes into one program.
4. Add Preprocessing

Alternative 14: 92.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{y}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -0.165:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 0.145:\\ \;\;\;\;\left(x + -2\right) \cdot \left(0.0212463641547976 \cdot z + x \cdot \left(0.0212463641547976 \cdot y + z \cdot -0.14147091005106402\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* (+ x -2.0) (+ 4.16438922228 (/ y (* x (* x x)))))))
   (if (<= x -0.165)
     t_0
     (if (<= x 0.145)
       (*
        (+ x -2.0)
        (+
         (* 0.0212463641547976 z)
         (* x (+ (* 0.0212463641547976 y) (* z -0.14147091005106402)))))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -0.165) {
		tmp = t_0;
	} else if (x <= 0.145) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + (y / (x * (x * x))))
    if (x <= (-0.165d0)) then
        tmp = t_0
    else if (x <= 0.145d0) then
        tmp = (x + (-2.0d0)) * ((0.0212463641547976d0 * z) + (x * ((0.0212463641547976d0 * y) + (z * (-0.14147091005106402d0)))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -0.165) {
		tmp = t_0;
	} else if (x <= 0.145) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))))
	tmp = 0
	if x <= -0.165:
		tmp = t_0
	elif x <= 0.145:
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(y / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -0.165)
		tmp = t_0;
	elseif (x <= 0.145)
		tmp = Float64(Float64(x + -2.0) * Float64(Float64(0.0212463641547976 * z) + Float64(x * Float64(Float64(0.0212463641547976 * y) + Float64(z * -0.14147091005106402)))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	tmp = 0.0;
	if (x <= -0.165)
		tmp = t_0;
	elseif (x <= 0.145)
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (x * ((0.0212463641547976 * y) + (z * -0.14147091005106402))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(y / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -0.165], t$95$0, If[LessEqual[x, 0.145], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(0.0212463641547976 * z), $MachinePrecision] + N[(x * N[(N[(0.0212463641547976 * y), $MachinePrecision] + N[(z * -0.14147091005106402), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -0.165000000000000008 or 0.14499999999999999 < x

   1. Initial program 15.6%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -0.165000000000000008 < x < 0.14499999999999999

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 15: 76.6% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x + -2}{0.24013125253755718 + \frac{5.86923874282773}{x}}\\ \mathbf{if}\;x \leq -5.5:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq -8 \cdot 10^{-81}:\\ \;\;\;\;\left(\left(x + -2\right) \cdot \left(y \cdot 0.0212463641547976 + z \cdot -0.14147091005106402\right)\right) \cdot x\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{x + -2}{\frac{47.066876606}{z}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (/ (+ x -2.0) (+ 0.24013125253755718 (/ 5.86923874282773 x)))))
   (if (<= x -5.5)
     t_0
     (if (<= x -8e-81)
       (*
        (* (+ x -2.0) (+ (* y 0.0212463641547976) (* z -0.14147091005106402)))
        x)
       (if (<= x 17000000000.0) (/ (+ x -2.0) (/ 47.066876606 z)) t_0)))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= -8e-81) {
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) / (0.24013125253755718d0 + (5.86923874282773d0 / x))
    if (x <= (-5.5d0)) then
        tmp = t_0
    else if (x <= (-8d-81)) then
        tmp = ((x + (-2.0d0)) * ((y * 0.0212463641547976d0) + (z * (-0.14147091005106402d0)))) * x
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) / (47.066876606d0 / z)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= -8e-81) {
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x))
	tmp = 0
	if x <= -5.5:
		tmp = t_0
	elif x <= -8e-81:
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x
	elif x <= 17000000000.0:
		tmp = (x + -2.0) / (47.066876606 / z)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) / Float64(0.24013125253755718 + Float64(5.86923874282773 / x)))
	tmp = 0.0
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= -8e-81)
		tmp = Float64(Float64(Float64(x + -2.0) * Float64(Float64(y * 0.0212463641547976) + Float64(z * -0.14147091005106402))) * x);
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) / Float64(47.066876606 / z));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	tmp = 0.0;
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= -8e-81)
		tmp = ((x + -2.0) * ((y * 0.0212463641547976) + (z * -0.14147091005106402))) * x;
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) / (47.066876606 / z);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] / N[(0.24013125253755718 + N[(5.86923874282773 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.5], t$95$0, If[LessEqual[x, -8e-81], N[(N[(N[(x + -2.0), $MachinePrecision] * N[(N[(y * 0.0212463641547976), $MachinePrecision] + N[(z * -0.14147091005106402), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 / z), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if x < -5.5 or 1.7e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -5.5 < x < -7.9999999999999997e-81

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   12. Applied egg-rr 0

       \[\leadsto expr\]

   if -7.9999999999999997e-81 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 16: 76.4% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x + -2}{0.24013125253755718 + \frac{5.86923874282773}{x}}\\ \mathbf{if}\;x \leq -0.175:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq -1.15 \cdot 10^{-79}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(x \cdot \left(0.0212463641547976 \cdot y\right)\right)\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{x + -2}{\frac{47.066876606}{z}}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (/ (+ x -2.0) (+ 0.24013125253755718 (/ 5.86923874282773 x)))))
   (if (<= x -0.175)
     t_0
     (if (<= x -1.15e-79)
       (* (+ x -2.0) (* x (* 0.0212463641547976 y)))
       (if (<= x 17000000000.0) (/ (+ x -2.0) (/ 47.066876606 z)) t_0)))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	double tmp;
	if (x <= -0.175) {
		tmp = t_0;
	} else if (x <= -1.15e-79) {
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) / (0.24013125253755718d0 + (5.86923874282773d0 / x))
    if (x <= (-0.175d0)) then
        tmp = t_0
    else if (x <= (-1.15d-79)) then
        tmp = (x + (-2.0d0)) * (x * (0.0212463641547976d0 * y))
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) / (47.066876606d0 / z)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	double tmp;
	if (x <= -0.175) {
		tmp = t_0;
	} else if (x <= -1.15e-79) {
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x))
	tmp = 0
	if x <= -0.175:
		tmp = t_0
	elif x <= -1.15e-79:
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y))
	elif x <= 17000000000.0:
		tmp = (x + -2.0) / (47.066876606 / z)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) / Float64(0.24013125253755718 + Float64(5.86923874282773 / x)))
	tmp = 0.0
	if (x <= -0.175)
		tmp = t_0;
	elseif (x <= -1.15e-79)
		tmp = Float64(Float64(x + -2.0) * Float64(x * Float64(0.0212463641547976 * y)));
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) / Float64(47.066876606 / z));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) / (0.24013125253755718 + (5.86923874282773 / x));
	tmp = 0.0;
	if (x <= -0.175)
		tmp = t_0;
	elseif (x <= -1.15e-79)
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) / (47.066876606 / z);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] / N[(0.24013125253755718 + N[(5.86923874282773 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -0.175], t$95$0, If[LessEqual[x, -1.15e-79], N[(N[(x + -2.0), $MachinePrecision] * N[(x * N[(0.0212463641547976 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 / z), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if x < -0.17499999999999999 or 1.7e10 < x

   1. Initial program 13.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.17499999999999999 < x < -1.15000000000000006e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.15000000000000006e-79 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

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

Alternative 17: 92.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x + -2\right) \cdot \left(4.16438922228 + \frac{y}{x \cdot \left(x \cdot x\right)}\right)\\ \mathbf{if}\;x \leq -5.5:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 80000:\\ \;\;\;\;\left(x + -2\right) \cdot \left(0.0212463641547976 \cdot z + 0.0212463641547976 \cdot \left(x \cdot y\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* (+ x -2.0) (+ 4.16438922228 (/ y (* x (* x x)))))))
   (if (<= x -5.5)
     t_0
     (if (<= x 80000.0)
       (*
        (+ x -2.0)
        (+ (* 0.0212463641547976 z) (* 0.0212463641547976 (* x y))))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= 80000.0) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (0.0212463641547976 * (x * y)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) * (4.16438922228d0 + (y / (x * (x * x))))
    if (x <= (-5.5d0)) then
        tmp = t_0
    else if (x <= 80000.0d0) then
        tmp = (x + (-2.0d0)) * ((0.0212463641547976d0 * z) + (0.0212463641547976d0 * (x * y)))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	double tmp;
	if (x <= -5.5) {
		tmp = t_0;
	} else if (x <= 80000.0) {
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (0.0212463641547976 * (x * y)));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))))
	tmp = 0
	if x <= -5.5:
		tmp = t_0
	elif x <= 80000.0:
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (0.0212463641547976 * (x * y)))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) * Float64(4.16438922228 + Float64(y / Float64(x * Float64(x * x)))))
	tmp = 0.0
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= 80000.0)
		tmp = Float64(Float64(x + -2.0) * Float64(Float64(0.0212463641547976 * z) + Float64(0.0212463641547976 * Float64(x * y))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) * (4.16438922228 + (y / (x * (x * x))));
	tmp = 0.0;
	if (x <= -5.5)
		tmp = t_0;
	elseif (x <= 80000.0)
		tmp = (x + -2.0) * ((0.0212463641547976 * z) + (0.0212463641547976 * (x * y)));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] * N[(4.16438922228 + N[(y / N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.5], t$95$0, If[LessEqual[x, 80000.0], N[(N[(x + -2.0), $MachinePrecision] * N[(N[(0.0212463641547976 * z), $MachinePrecision] + N[(0.0212463641547976 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -5.5 or 8e4 < x

   1. Initial program 15.0%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -5.5 < x < 8e4

   1. Initial program 99.7%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   10. Simplified 0

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

Alternative 18: 76.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.026:\\ \;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811}{x}\right)\\ \mathbf{elif}\;x \leq -3.3 \cdot 10^{-80}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(x \cdot \left(0.0212463641547976 \cdot y\right)\right)\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{x + -2}{\frac{47.066876606}{z}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x + -2}{0.24013125253755718}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.026)
   (* x (+ 4.16438922228 (/ -110.1139242984811 x)))
   (if (<= x -3.3e-80)
     (* (+ x -2.0) (* x (* 0.0212463641547976 y)))
     (if (<= x 17000000000.0)
       (/ (+ x -2.0) (/ 47.066876606 z))
       (/ (+ x -2.0) 0.24013125253755718)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.026) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -3.3e-80) {
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.026d0)) then
        tmp = x * (4.16438922228d0 + ((-110.1139242984811d0) / x))
    else if (x <= (-3.3d-80)) then
        tmp = (x + (-2.0d0)) * (x * (0.0212463641547976d0 * y))
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) / (47.066876606d0 / z)
    else
        tmp = (x + (-2.0d0)) / 0.24013125253755718d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.026) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -3.3e-80) {
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.026:
		tmp = x * (4.16438922228 + (-110.1139242984811 / x))
	elif x <= -3.3e-80:
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y))
	elif x <= 17000000000.0:
		tmp = (x + -2.0) / (47.066876606 / z)
	else:
		tmp = (x + -2.0) / 0.24013125253755718
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.026)
		tmp = Float64(x * Float64(4.16438922228 + Float64(-110.1139242984811 / x)));
	elseif (x <= -3.3e-80)
		tmp = Float64(Float64(x + -2.0) * Float64(x * Float64(0.0212463641547976 * y)));
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) / Float64(47.066876606 / z));
	else
		tmp = Float64(Float64(x + -2.0) / 0.24013125253755718);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.026)
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	elseif (x <= -3.3e-80)
		tmp = (x + -2.0) * (x * (0.0212463641547976 * y));
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) / (47.066876606 / z);
	else
		tmp = (x + -2.0) / 0.24013125253755718;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.026], N[(x * N[(4.16438922228 + N[(-110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.3e-80], N[(N[(x + -2.0), $MachinePrecision] * N[(x * N[(0.0212463641547976 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 / z), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -0.0259999999999999988

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.0259999999999999988 < x < -3.3e-80

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -3.3e-80 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.7e10 < x

   1. Initial program 7.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   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 19: 76.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.16:\\ \;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811}{x}\right)\\ \mathbf{elif}\;x \leq -1.15 \cdot 10^{-79}:\\ \;\;\;\;\left(x + -2\right) \cdot \left(0.0212463641547976 \cdot \left(x \cdot y\right)\right)\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{x + -2}{\frac{47.066876606}{z}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x + -2}{0.24013125253755718}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.16)
   (* x (+ 4.16438922228 (/ -110.1139242984811 x)))
   (if (<= x -1.15e-79)
     (* (+ x -2.0) (* 0.0212463641547976 (* x y)))
     (if (<= x 17000000000.0)
       (/ (+ x -2.0) (/ 47.066876606 z))
       (/ (+ x -2.0) 0.24013125253755718)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.16) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.15e-79) {
		tmp = (x + -2.0) * (0.0212463641547976 * (x * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.16d0)) then
        tmp = x * (4.16438922228d0 + ((-110.1139242984811d0) / x))
    else if (x <= (-1.15d-79)) then
        tmp = (x + (-2.0d0)) * (0.0212463641547976d0 * (x * y))
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) / (47.066876606d0 / z)
    else
        tmp = (x + (-2.0d0)) / 0.24013125253755718d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.16) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.15e-79) {
		tmp = (x + -2.0) * (0.0212463641547976 * (x * y));
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.16:
		tmp = x * (4.16438922228 + (-110.1139242984811 / x))
	elif x <= -1.15e-79:
		tmp = (x + -2.0) * (0.0212463641547976 * (x * y))
	elif x <= 17000000000.0:
		tmp = (x + -2.0) / (47.066876606 / z)
	else:
		tmp = (x + -2.0) / 0.24013125253755718
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.16)
		tmp = Float64(x * Float64(4.16438922228 + Float64(-110.1139242984811 / x)));
	elseif (x <= -1.15e-79)
		tmp = Float64(Float64(x + -2.0) * Float64(0.0212463641547976 * Float64(x * y)));
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) / Float64(47.066876606 / z));
	else
		tmp = Float64(Float64(x + -2.0) / 0.24013125253755718);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.16)
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	elseif (x <= -1.15e-79)
		tmp = (x + -2.0) * (0.0212463641547976 * (x * y));
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) / (47.066876606 / z);
	else
		tmp = (x + -2.0) / 0.24013125253755718;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.16], N[(x * N[(4.16438922228 + N[(-110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.15e-79], N[(N[(x + -2.0), $MachinePrecision] * N[(0.0212463641547976 * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 / z), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -0.160000000000000003

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.160000000000000003 < x < -1.15000000000000006e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x 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.15000000000000006e-79 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.7e10 < x

   1. Initial program 7.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   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 20: 76.3% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -65:\\ \;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811}{x}\right)\\ \mathbf{elif}\;x \leq -1.25 \cdot 10^{-79}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\frac{x + -2}{\frac{47.066876606}{z}}\\ \mathbf{else}:\\ \;\;\;\;\frac{x + -2}{0.24013125253755718}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -65.0)
   (* x (+ 4.16438922228 (/ -110.1139242984811 x)))
   (if (<= x -1.25e-79)
     (* (* x y) -0.0424927283095952)
     (if (<= x 17000000000.0)
       (/ (+ x -2.0) (/ 47.066876606 z))
       (/ (+ x -2.0) 0.24013125253755718)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -65.0) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.25e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-65.0d0)) then
        tmp = x * (4.16438922228d0 + ((-110.1139242984811d0) / x))
    else if (x <= (-1.25d-79)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) / (47.066876606d0 / z)
    else
        tmp = (x + (-2.0d0)) / 0.24013125253755718d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -65.0) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.25e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) / (47.066876606 / z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -65.0:
		tmp = x * (4.16438922228 + (-110.1139242984811 / x))
	elif x <= -1.25e-79:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 17000000000.0:
		tmp = (x + -2.0) / (47.066876606 / z)
	else:
		tmp = (x + -2.0) / 0.24013125253755718
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -65.0)
		tmp = Float64(x * Float64(4.16438922228 + Float64(-110.1139242984811 / x)));
	elseif (x <= -1.25e-79)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) / Float64(47.066876606 / z));
	else
		tmp = Float64(Float64(x + -2.0) / 0.24013125253755718);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -65.0)
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	elseif (x <= -1.25e-79)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) / (47.066876606 / z);
	else
		tmp = (x + -2.0) / 0.24013125253755718;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -65.0], N[(x * N[(4.16438922228 + N[(-110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.25e-79], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] / N[(47.066876606 / z), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -65

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -65 < x < -1.25e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.25e-79 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.7e10 < x

   1. Initial program 7.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   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 21: 76.2% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.08:\\ \;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811}{x}\right)\\ \mathbf{elif}\;x \leq -1.06 \cdot 10^{-79}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 17000000000:\\ \;\;\;\;\left(x + -2\right) \cdot \left(0.0212463641547976 \cdot z\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{x + -2}{0.24013125253755718}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.08)
   (* x (+ 4.16438922228 (/ -110.1139242984811 x)))
   (if (<= x -1.06e-79)
     (* (* x y) -0.0424927283095952)
     (if (<= x 17000000000.0)
       (* (+ x -2.0) (* 0.0212463641547976 z))
       (/ (+ x -2.0) 0.24013125253755718)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.08) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.06e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) * (0.0212463641547976 * z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.08d0)) then
        tmp = x * (4.16438922228d0 + ((-110.1139242984811d0) / x))
    else if (x <= (-1.06d-79)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 17000000000.0d0) then
        tmp = (x + (-2.0d0)) * (0.0212463641547976d0 * z)
    else
        tmp = (x + (-2.0d0)) / 0.24013125253755718d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.08) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.06e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 17000000000.0) {
		tmp = (x + -2.0) * (0.0212463641547976 * z);
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.08:
		tmp = x * (4.16438922228 + (-110.1139242984811 / x))
	elif x <= -1.06e-79:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 17000000000.0:
		tmp = (x + -2.0) * (0.0212463641547976 * z)
	else:
		tmp = (x + -2.0) / 0.24013125253755718
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.08)
		tmp = Float64(x * Float64(4.16438922228 + Float64(-110.1139242984811 / x)));
	elseif (x <= -1.06e-79)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 17000000000.0)
		tmp = Float64(Float64(x + -2.0) * Float64(0.0212463641547976 * z));
	else
		tmp = Float64(Float64(x + -2.0) / 0.24013125253755718);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.08)
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	elseif (x <= -1.06e-79)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 17000000000.0)
		tmp = (x + -2.0) * (0.0212463641547976 * z);
	else
		tmp = (x + -2.0) / 0.24013125253755718;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.08], N[(x * N[(4.16438922228 + N[(-110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.06e-79], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 17000000000.0], N[(N[(x + -2.0), $MachinePrecision] * N[(0.0212463641547976 * z), $MachinePrecision]), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -0.0800000000000000017

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.0800000000000000017 < x < -1.06000000000000005e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.06000000000000005e-79 < x < 1.7e10

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.7e10 < x

   1. Initial program 7.4%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   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 22: 76.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.105:\\ \;\;\;\;x \cdot \left(4.16438922228 + \frac{-110.1139242984811}{x}\right)\\ \mathbf{elif}\;x \leq -1.06 \cdot 10^{-79}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 2400000:\\ \;\;\;\;z \cdot -0.0424927283095952\\ \mathbf{else}:\\ \;\;\;\;\frac{x + -2}{0.24013125253755718}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.105)
   (* x (+ 4.16438922228 (/ -110.1139242984811 x)))
   (if (<= x -1.06e-79)
     (* (* x y) -0.0424927283095952)
     (if (<= x 2400000.0)
       (* z -0.0424927283095952)
       (/ (+ x -2.0) 0.24013125253755718)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.105) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.06e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 2400000.0) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.105d0)) then
        tmp = x * (4.16438922228d0 + ((-110.1139242984811d0) / x))
    else if (x <= (-1.06d-79)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 2400000.0d0) then
        tmp = z * (-0.0424927283095952d0)
    else
        tmp = (x + (-2.0d0)) / 0.24013125253755718d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.105) {
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	} else if (x <= -1.06e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 2400000.0) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = (x + -2.0) / 0.24013125253755718;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.105:
		tmp = x * (4.16438922228 + (-110.1139242984811 / x))
	elif x <= -1.06e-79:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 2400000.0:
		tmp = z * -0.0424927283095952
	else:
		tmp = (x + -2.0) / 0.24013125253755718
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.105)
		tmp = Float64(x * Float64(4.16438922228 + Float64(-110.1139242984811 / x)));
	elseif (x <= -1.06e-79)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 2400000.0)
		tmp = Float64(z * -0.0424927283095952);
	else
		tmp = Float64(Float64(x + -2.0) / 0.24013125253755718);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.105)
		tmp = x * (4.16438922228 + (-110.1139242984811 / x));
	elseif (x <= -1.06e-79)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 2400000.0)
		tmp = z * -0.0424927283095952;
	else
		tmp = (x + -2.0) / 0.24013125253755718;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.105], N[(x * N[(4.16438922228 + N[(-110.1139242984811 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.06e-79], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 2400000.0], N[(z * -0.0424927283095952), $MachinePrecision], N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -0.104999999999999996

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.104999999999999996 < x < -1.06000000000000005e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.06000000000000005e-79 < x < 2.4e6

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 2.4e6 < x

   1. Initial program 9.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   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 23: 76.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x + -2}{0.24013125253755718}\\ \mathbf{if}\;x \leq -0.038:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq -1.25 \cdot 10^{-79}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 2400000:\\ \;\;\;\;z \cdot -0.0424927283095952\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (/ (+ x -2.0) 0.24013125253755718)))
   (if (<= x -0.038)
     t_0
     (if (<= x -1.25e-79)
       (* (* x y) -0.0424927283095952)
       (if (<= x 2400000.0) (* z -0.0424927283095952) t_0)))))

C

double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / 0.24013125253755718;
	double tmp;
	if (x <= -0.038) {
		tmp = t_0;
	} else if (x <= -1.25e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 2400000.0) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x + (-2.0d0)) / 0.24013125253755718d0
    if (x <= (-0.038d0)) then
        tmp = t_0
    else if (x <= (-1.25d-79)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 2400000.0d0) then
        tmp = z * (-0.0424927283095952d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x + -2.0) / 0.24013125253755718;
	double tmp;
	if (x <= -0.038) {
		tmp = t_0;
	} else if (x <= -1.25e-79) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 2400000.0) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x + -2.0) / 0.24013125253755718
	tmp = 0
	if x <= -0.038:
		tmp = t_0
	elif x <= -1.25e-79:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 2400000.0:
		tmp = z * -0.0424927283095952
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x + -2.0) / 0.24013125253755718)
	tmp = 0.0
	if (x <= -0.038)
		tmp = t_0;
	elseif (x <= -1.25e-79)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 2400000.0)
		tmp = Float64(z * -0.0424927283095952);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x + -2.0) / 0.24013125253755718;
	tmp = 0.0;
	if (x <= -0.038)
		tmp = t_0;
	elseif (x <= -1.25e-79)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 2400000.0)
		tmp = z * -0.0424927283095952;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + -2.0), $MachinePrecision] / 0.24013125253755718), $MachinePrecision]}, If[LessEqual[x, -0.038], t$95$0, If[LessEqual[x, -1.25e-79], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 2400000.0], N[(z * -0.0424927283095952), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if x < -0.0379999999999999991 or 2.4e6 < x

   1. Initial program 15.0%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if -0.0379999999999999991 < x < -1.25e-79

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.25e-79 < x < 2.4e6

   1. Initial program 98.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 24: 76.0% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -5.5:\\ \;\;\;\;\left(x + -2\right) \cdot 4.16438922228\\ \mathbf{elif}\;x \leq -9 \cdot 10^{-80}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 0.00072:\\ \;\;\;\;z \cdot -0.0424927283095952\\ \mathbf{else}:\\ \;\;\;\;x \cdot 4.16438922228\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -5.5)
   (* (+ x -2.0) 4.16438922228)
   (if (<= x -9e-80)
     (* (* x y) -0.0424927283095952)
     (if (<= x 0.00072) (* z -0.0424927283095952) (* x 4.16438922228)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -5.5) {
		tmp = (x + -2.0) * 4.16438922228;
	} else if (x <= -9e-80) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-5.5d0)) then
        tmp = (x + (-2.0d0)) * 4.16438922228d0
    else if (x <= (-9d-80)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 0.00072d0) then
        tmp = z * (-0.0424927283095952d0)
    else
        tmp = x * 4.16438922228d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -5.5) {
		tmp = (x + -2.0) * 4.16438922228;
	} else if (x <= -9e-80) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -5.5:
		tmp = (x + -2.0) * 4.16438922228
	elif x <= -9e-80:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 0.00072:
		tmp = z * -0.0424927283095952
	else:
		tmp = x * 4.16438922228
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -5.5)
		tmp = Float64(Float64(x + -2.0) * 4.16438922228);
	elseif (x <= -9e-80)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 0.00072)
		tmp = Float64(z * -0.0424927283095952);
	else
		tmp = Float64(x * 4.16438922228);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -5.5)
		tmp = (x + -2.0) * 4.16438922228;
	elseif (x <= -9e-80)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 0.00072)
		tmp = z * -0.0424927283095952;
	else
		tmp = x * 4.16438922228;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -5.5], N[(N[(x + -2.0), $MachinePrecision] * 4.16438922228), $MachinePrecision], If[LessEqual[x, -9e-80], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 0.00072], N[(z * -0.0424927283095952), $MachinePrecision], N[(x * 4.16438922228), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < -5.5

   1. Initial program 21.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   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.5 < x < -9.0000000000000006e-80

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -9.0000000000000006e-80 < x < 7.20000000000000045e-4

   1. Initial program 99.8%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 7.20000000000000045e-4 < x

   1. Initial program 12.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 25: 76.0% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -0.06:\\ \;\;\;\;x \cdot 4.16438922228\\ \mathbf{elif}\;x \leq -9 \cdot 10^{-81}:\\ \;\;\;\;\left(x \cdot y\right) \cdot -0.0424927283095952\\ \mathbf{elif}\;x \leq 0.00072:\\ \;\;\;\;z \cdot -0.0424927283095952\\ \mathbf{else}:\\ \;\;\;\;x \cdot 4.16438922228\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -0.06)
   (* x 4.16438922228)
   (if (<= x -9e-81)
     (* (* x y) -0.0424927283095952)
     (if (<= x 0.00072) (* z -0.0424927283095952) (* x 4.16438922228)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.06) {
		tmp = x * 4.16438922228;
	} else if (x <= -9e-81) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-0.06d0)) then
        tmp = x * 4.16438922228d0
    else if (x <= (-9d-81)) then
        tmp = (x * y) * (-0.0424927283095952d0)
    else if (x <= 0.00072d0) then
        tmp = z * (-0.0424927283095952d0)
    else
        tmp = x * 4.16438922228d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -0.06) {
		tmp = x * 4.16438922228;
	} else if (x <= -9e-81) {
		tmp = (x * y) * -0.0424927283095952;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -0.06:
		tmp = x * 4.16438922228
	elif x <= -9e-81:
		tmp = (x * y) * -0.0424927283095952
	elif x <= 0.00072:
		tmp = z * -0.0424927283095952
	else:
		tmp = x * 4.16438922228
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -0.06)
		tmp = Float64(x * 4.16438922228);
	elseif (x <= -9e-81)
		tmp = Float64(Float64(x * y) * -0.0424927283095952);
	elseif (x <= 0.00072)
		tmp = Float64(z * -0.0424927283095952);
	else
		tmp = Float64(x * 4.16438922228);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -0.06)
		tmp = x * 4.16438922228;
	elseif (x <= -9e-81)
		tmp = (x * y) * -0.0424927283095952;
	elseif (x <= 0.00072)
		tmp = z * -0.0424927283095952;
	else
		tmp = x * 4.16438922228;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -0.06], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, -9e-81], N[(N[(x * y), $MachinePrecision] * -0.0424927283095952), $MachinePrecision], If[LessEqual[x, 0.00072], N[(z * -0.0424927283095952), $MachinePrecision], N[(x * 4.16438922228), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if x < -0.059999999999999998 or 7.20000000000000045e-4 < x

   1. Initial program 16.1%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -0.059999999999999998 < x < -9.000000000000001e-81

   1. Initial program 99.3%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -9.000000000000001e-81 < x < 7.20000000000000045e-4

   1. Initial program 99.8%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 26: 76.0% accurate, 2.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.75 \cdot 10^{-31}:\\ \;\;\;\;x \cdot 4.16438922228\\ \mathbf{elif}\;x \leq 0.00072:\\ \;\;\;\;z \cdot -0.0424927283095952\\ \mathbf{else}:\\ \;\;\;\;x \cdot 4.16438922228\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -2.75e-31)
   (* x 4.16438922228)
   (if (<= x 0.00072) (* z -0.0424927283095952) (* x 4.16438922228))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -2.75e-31) {
		tmp = x * 4.16438922228;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-2.75d-31)) then
        tmp = x * 4.16438922228d0
    else if (x <= 0.00072d0) then
        tmp = z * (-0.0424927283095952d0)
    else
        tmp = x * 4.16438922228d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -2.75e-31) {
		tmp = x * 4.16438922228;
	} else if (x <= 0.00072) {
		tmp = z * -0.0424927283095952;
	} else {
		tmp = x * 4.16438922228;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -2.75e-31:
		tmp = x * 4.16438922228
	elif x <= 0.00072:
		tmp = z * -0.0424927283095952
	else:
		tmp = x * 4.16438922228
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -2.75e-31)
		tmp = Float64(x * 4.16438922228);
	elseif (x <= 0.00072)
		tmp = Float64(z * -0.0424927283095952);
	else
		tmp = Float64(x * 4.16438922228);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -2.75e-31)
		tmp = x * 4.16438922228;
	elseif (x <= 0.00072)
		tmp = z * -0.0424927283095952;
	else
		tmp = x * 4.16438922228;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -2.75e-31], N[(x * 4.16438922228), $MachinePrecision], If[LessEqual[x, 0.00072], N[(z * -0.0424927283095952), $MachinePrecision], N[(x * 4.16438922228), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if x < -2.74999999999999979e-31 or 7.20000000000000045e-4 < x

   1. Initial program 17.9%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -2.74999999999999979e-31 < x < 7.20000000000000045e-4

   1. Initial program 99.8%

      \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

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

Alternative 27: 45.0% accurate, 12.3× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (* x 4.16438922228))

C

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

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = x * 4.16438922228d0
end function

Java

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

Python

def code(x, y, z):
	return x * 4.16438922228

Julia

function code(x, y, z)
	return Float64(x * 4.16438922228)
end

MATLAB

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

Wolfram

code[x_, y_, z_] := N[(x * 4.16438922228), $MachinePrecision]

Derivation

1. Initial program 54.3%

   \[\frac{\left(x - 2\right) \cdot \left(\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z\right)}{\left(\left(\left(x + 43.3400022514\right) \cdot x + 263.505074721\right) \cdot x + 313.399215894\right) \cdot x + 47.066876606} \]
2. Add Preprocessing

3. Taylor expanded in x around inf 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Developer target: 98.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(\frac{y}{x \cdot x} + 4.16438922228 \cdot x\right) - 110.1139242984811\\ \mathbf{if}\;x < -3.326128725870005 \cdot 10^{+62}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x < 9.429991714554673 \cdot 10^{+55}:\\ \;\;\;\;\frac{x - 2}{1} \cdot \frac{\left(\left(\left(x \cdot 4.16438922228 + 78.6994924154\right) \cdot x + 137.519416416\right) \cdot x + y\right) \cdot x + z}{\left(\left(263.505074721 \cdot x + \left(43.3400022514 \cdot \left(x \cdot x\right) + x \cdot \left(x \cdot x\right)\right)\right) + 313.399215894\right) \cdot x + 47.066876606}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811)))
   (if (< x -3.326128725870005e+62)
     t_0
     (if (< x 9.429991714554673e+55)
       (*
        (/ (- x 2.0) 1.0)
        (/
         (+
          (*
           (+
            (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x)
            y)
           x)
          z)
         (+
          (*
           (+
            (+ (* 263.505074721 x) (+ (* 43.3400022514 (* x x)) (* x (* x x))))
            313.399215894)
           x)
          47.066876606)))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811;
	double tmp;
	if (x < -3.326128725870005e+62) {
		tmp = t_0;
	} else if (x < 9.429991714554673e+55) {
		tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ((y / (x * x)) + (4.16438922228d0 * x)) - 110.1139242984811d0
    if (x < (-3.326128725870005d+62)) then
        tmp = t_0
    else if (x < 9.429991714554673d+55) then
        tmp = ((x - 2.0d0) / 1.0d0) * (((((((((x * 4.16438922228d0) + 78.6994924154d0) * x) + 137.519416416d0) * x) + y) * x) + z) / (((((263.505074721d0 * x) + ((43.3400022514d0 * (x * x)) + (x * (x * x)))) + 313.399215894d0) * x) + 47.066876606d0))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811;
	double tmp;
	if (x < -3.326128725870005e+62) {
		tmp = t_0;
	} else if (x < 9.429991714554673e+55) {
		tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811
	tmp = 0
	if x < -3.326128725870005e+62:
		tmp = t_0
	elif x < 9.429991714554673e+55:
		tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(Float64(y / Float64(x * x)) + Float64(4.16438922228 * x)) - 110.1139242984811)
	tmp = 0.0
	if (x < -3.326128725870005e+62)
		tmp = t_0;
	elseif (x < 9.429991714554673e+55)
		tmp = Float64(Float64(Float64(x - 2.0) / 1.0) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / Float64(Float64(Float64(Float64(Float64(263.505074721 * x) + Float64(Float64(43.3400022514 * Float64(x * x)) + Float64(x * Float64(x * x)))) + 313.399215894) * x) + 47.066876606)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = ((y / (x * x)) + (4.16438922228 * x)) - 110.1139242984811;
	tmp = 0.0;
	if (x < -3.326128725870005e+62)
		tmp = t_0;
	elseif (x < 9.429991714554673e+55)
		tmp = ((x - 2.0) / 1.0) * (((((((((x * 4.16438922228) + 78.6994924154) * x) + 137.519416416) * x) + y) * x) + z) / (((((263.505074721 * x) + ((43.3400022514 * (x * x)) + (x * (x * x)))) + 313.399215894) * x) + 47.066876606));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(4.16438922228 * x), $MachinePrecision]), $MachinePrecision] - 110.1139242984811), $MachinePrecision]}, If[Less[x, -3.326128725870005e+62], t$95$0, If[Less[x, 9.429991714554673e+55], N[(N[(N[(x - 2.0), $MachinePrecision] / 1.0), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(N[(x * 4.16438922228), $MachinePrecision] + 78.6994924154), $MachinePrecision] * x), $MachinePrecision] + 137.519416416), $MachinePrecision] * x), $MachinePrecision] + y), $MachinePrecision] * x), $MachinePrecision] + z), $MachinePrecision] / N[(N[(N[(N[(N[(263.505074721 * x), $MachinePrecision] + N[(N[(43.3400022514 * N[(x * x), $MachinePrecision]), $MachinePrecision] + N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 313.399215894), $MachinePrecision] * x), $MachinePrecision] + 47.066876606), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z)
  :name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2, C"
  :precision binary64

  :alt
  (if (< x -3.326128725870005e+62) (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811) (if (< x 9.429991714554673e+55) (* (/ (- x 2.0) 1.0) (/ (+ (* (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y) x) z) (+ (* (+ (+ (* 263.505074721 x) (+ (* 43.3400022514 (* x x)) (* x (* x x)))) 313.399215894) x) 47.066876606))) (- (+ (/ y (* x x)) (* 4.16438922228 x)) 110.1139242984811)))

  (/ (* (- x 2.0) (+ (* (+ (* (+ (* (+ (* x 4.16438922228) 78.6994924154) x) 137.519416416) x) y) x) z)) (+ (* (+ (* (+ (* (+ x 43.3400022514) x) 263.505074721) x) 313.399215894) x) 47.066876606)))