Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2

Percentage Accurate: 56.5% → 81.4%

Time: 27.8s

Alternatives: 21

Speedup: 1.7×

Specification

Math

\[\begin{array}{l} \\ \frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Initial Program: 56.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (/
  (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t)
  (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}

Python

def code(x, y, z, t, a, b, c, i):
	return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)

Julia

function code(x, y, z, t, a, b, c, i)
	return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i))
end

MATLAB

function tmp = code(x, y, z, t, a, b, c, i)
	tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]

Alternative 1: 81.4% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{{x}^{2}}\\ t_2 := i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)\\ t_3 := \frac{y}{\left(\left(\frac{y}{x} + \frac{a}{x}\right) + \frac{\left(\frac{b}{x} - \frac{27464.7644705}{{x}^{2}}\right) - \frac{z}{\frac{x}{\frac{a}{x} - t_1}}}{y}\right) - t_1}\\ \mathbf{if}\;y \leq -9.8 \cdot 10^{+58}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y \leq 4 \cdot 10^{+45}:\\ \;\;\;\;\frac{t}{t_2} + \frac{y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{t_2}\\ \mathbf{elif}\;y \leq 5.8 \cdot 10^{+140}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (/ z (pow x 2.0)))
        (t_2 (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
        (t_3
         (/
          y
          (-
           (+
            (+ (/ y x) (/ a x))
            (/
             (-
              (- (/ b x) (/ 27464.7644705 (pow x 2.0)))
              (/ z (/ x (- (/ a x) t_1))))
             y))
           t_1))))
   (if (<= y -9.8e+58)
     t_3
     (if (<= y 4e+45)
       (+
        (/ t t_2)
        (/
         (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x)))))))
         t_2))
       (if (<= y 5.8e+140) t_3 (+ x (- (/ z y) (/ a (/ y x)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = z / pow(x, 2.0);
	double t_2 = i + (y * (c + (y * (b + (y * (y + a))))));
	double t_3 = y / ((((y / x) + (a / x)) + ((((b / x) - (27464.7644705 / pow(x, 2.0))) - (z / (x / ((a / x) - t_1)))) / y)) - t_1);
	double tmp;
	if (y <= -9.8e+58) {
		tmp = t_3;
	} else if (y <= 4e+45) {
		tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2);
	} else if (y <= 5.8e+140) {
		tmp = t_3;
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_1 = z / (x ** 2.0d0)
    t_2 = i + (y * (c + (y * (b + (y * (y + a))))))
    t_3 = y / ((((y / x) + (a / x)) + ((((b / x) - (27464.7644705d0 / (x ** 2.0d0))) - (z / (x / ((a / x) - t_1)))) / y)) - t_1)
    if (y <= (-9.8d+58)) then
        tmp = t_3
    else if (y <= 4d+45) then
        tmp = (t / t_2) + ((y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x))))))) / t_2)
    else if (y <= 5.8d+140) then
        tmp = t_3
    else
        tmp = x + ((z / y) - (a / (y / x)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = z / Math.pow(x, 2.0);
	double t_2 = i + (y * (c + (y * (b + (y * (y + a))))));
	double t_3 = y / ((((y / x) + (a / x)) + ((((b / x) - (27464.7644705 / Math.pow(x, 2.0))) - (z / (x / ((a / x) - t_1)))) / y)) - t_1);
	double tmp;
	if (y <= -9.8e+58) {
		tmp = t_3;
	} else if (y <= 4e+45) {
		tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2);
	} else if (y <= 5.8e+140) {
		tmp = t_3;
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = z / math.pow(x, 2.0)
	t_2 = i + (y * (c + (y * (b + (y * (y + a))))))
	t_3 = y / ((((y / x) + (a / x)) + ((((b / x) - (27464.7644705 / math.pow(x, 2.0))) - (z / (x / ((a / x) - t_1)))) / y)) - t_1)
	tmp = 0
	if y <= -9.8e+58:
		tmp = t_3
	elif y <= 4e+45:
		tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2)
	elif y <= 5.8e+140:
		tmp = t_3
	else:
		tmp = x + ((z / y) - (a / (y / x)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(z / (x ^ 2.0))
	t_2 = Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a)))))))
	t_3 = Float64(y / Float64(Float64(Float64(Float64(y / x) + Float64(a / x)) + Float64(Float64(Float64(Float64(b / x) - Float64(27464.7644705 / (x ^ 2.0))) - Float64(z / Float64(x / Float64(Float64(a / x) - t_1)))) / y)) - t_1))
	tmp = 0.0
	if (y <= -9.8e+58)
		tmp = t_3;
	elseif (y <= 4e+45)
		tmp = Float64(Float64(t / t_2) + Float64(Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x))))))) / t_2));
	elseif (y <= 5.8e+140)
		tmp = t_3;
	else
		tmp = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = z / (x ^ 2.0);
	t_2 = i + (y * (c + (y * (b + (y * (y + a))))));
	t_3 = y / ((((y / x) + (a / x)) + ((((b / x) - (27464.7644705 / (x ^ 2.0))) - (z / (x / ((a / x) - t_1)))) / y)) - t_1);
	tmp = 0.0;
	if (y <= -9.8e+58)
		tmp = t_3;
	elseif (y <= 4e+45)
		tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2);
	elseif (y <= 5.8e+140)
		tmp = t_3;
	else
		tmp = x + ((z / y) - (a / (y / x)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(z / N[Power[x, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y / N[(N[(N[(N[(y / x), $MachinePrecision] + N[(a / x), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(b / x), $MachinePrecision] - N[(27464.7644705 / N[Power[x, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(z / N[(x / N[(N[(a / x), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9.8e+58], t$95$3, If[LessEqual[y, 4e+45], N[(N[(t / t$95$2), $MachinePrecision] + N[(N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e+140], t$95$3, N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 81.1% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)\\ \mathbf{if}\;y \leq -2.6 \cdot 10^{+58}:\\ \;\;\;\;\frac{y}{\left(\frac{y}{x} + \frac{a}{x}\right) - \frac{z}{{x}^{2}}}\\ \mathbf{elif}\;y \leq 4.4 \cdot 10^{+67}:\\ \;\;\;\;\frac{t}{t_1} + \frac{y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{t_1}\\ \mathbf{elif}\;y \leq 3.3 \cdot 10^{+112}:\\ \;\;\;\;\frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ \mathbf{else}:\\ \;\;\;\;x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ i (* y (+ c (* y (+ b (* y (+ y a)))))))))
   (if (<= y -2.6e+58)
     (/ y (- (+ (/ y x) (/ a x)) (/ z (pow x 2.0))))
     (if (<= y 4.4e+67)
       (+
        (/ t t_1)
        (/
         (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x)))))))
         t_1))
       (if (<= y 3.3e+112)
         (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y))))
         (+ x (- (/ z y) (/ a (/ y x)))))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	double tmp;
	if (y <= -2.6e+58) {
		tmp = y / (((y / x) + (a / x)) - (z / pow(x, 2.0)));
	} else if (y <= 4.4e+67) {
		tmp = (t / t_1) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_1);
	} else if (y <= 3.3e+112) {
		tmp = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = i + (y * (c + (y * (b + (y * (y + a))))))
    if (y <= (-2.6d+58)) then
        tmp = y / (((y / x) + (a / x)) - (z / (x ** 2.0d0)))
    else if (y <= 4.4d+67) then
        tmp = (t / t_1) + ((y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x))))))) / t_1)
    else if (y <= 3.3d+112) then
        tmp = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    else
        tmp = x + ((z / y) - (a / (y / x)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	double tmp;
	if (y <= -2.6e+58) {
		tmp = y / (((y / x) + (a / x)) - (z / Math.pow(x, 2.0)));
	} else if (y <= 4.4e+67) {
		tmp = (t / t_1) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_1);
	} else if (y <= 3.3e+112) {
		tmp = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = i + (y * (c + (y * (b + (y * (y + a))))))
	tmp = 0
	if y <= -2.6e+58:
		tmp = y / (((y / x) + (a / x)) - (z / math.pow(x, 2.0)))
	elif y <= 4.4e+67:
		tmp = (t / t_1) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_1)
	elif y <= 3.3e+112:
		tmp = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	else:
		tmp = x + ((z / y) - (a / (y / x)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a)))))))
	tmp = 0.0
	if (y <= -2.6e+58)
		tmp = Float64(y / Float64(Float64(Float64(y / x) + Float64(a / x)) - Float64(z / (x ^ 2.0))));
	elseif (y <= 4.4e+67)
		tmp = Float64(Float64(t / t_1) + Float64(Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x))))))) / t_1));
	elseif (y <= 3.3e+112)
		tmp = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))));
	else
		tmp = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	tmp = 0.0;
	if (y <= -2.6e+58)
		tmp = y / (((y / x) + (a / x)) - (z / (x ^ 2.0)));
	elseif (y <= 4.4e+67)
		tmp = (t / t_1) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_1);
	elseif (y <= 3.3e+112)
		tmp = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	else
		tmp = x + ((z / y) - (a / (y / x)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.6e+58], N[(y / N[(N[(N[(y / x), $MachinePrecision] + N[(a / x), $MachinePrecision]), $MachinePrecision] - N[(z / N[Power[x, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.4e+67], N[(N[(t / t$95$1), $MachinePrecision] + N[(N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+112], N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 84.5% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)\\ t_2 := y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)\\ \mathbf{if}\;\frac{t + t_2}{t_1} \leq \infty:\\ \;\;\;\;\frac{t}{t_1} + \frac{t_2}{t_1}\\ \mathbf{else}:\\ \;\;\;\;x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
        (t_2
         (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x)))))))))
   (if (<= (/ (+ t t_2) t_1) INFINITY)
     (+ (/ t t_1) (/ t_2 t_1))
     (+ x (- (/ z y) (/ a (/ y x)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	double t_2 = y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))));
	double tmp;
	if (((t + t_2) / t_1) <= ((double) INFINITY)) {
		tmp = (t / t_1) + (t_2 / t_1);
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	double t_2 = y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))));
	double tmp;
	if (((t + t_2) / t_1) <= Double.POSITIVE_INFINITY) {
		tmp = (t / t_1) + (t_2 / t_1);
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = i + (y * (c + (y * (b + (y * (y + a))))))
	t_2 = y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))
	tmp = 0
	if ((t + t_2) / t_1) <= math.inf:
		tmp = (t / t_1) + (t_2 / t_1)
	else:
		tmp = x + ((z / y) - (a / (y / x)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a)))))))
	t_2 = Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))
	tmp = 0.0
	if (Float64(Float64(t + t_2) / t_1) <= Inf)
		tmp = Float64(Float64(t / t_1) + Float64(t_2 / t_1));
	else
		tmp = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = i + (y * (c + (y * (b + (y * (y + a))))));
	t_2 = y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))));
	tmp = 0.0;
	if (((t + t_2) / t_1) <= Inf)
		tmp = (t / t_1) + (t_2 / t_1);
	else
		tmp = x + ((z / y) - (a / (y / x)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t + t$95$2), $MachinePrecision] / t$95$1), $MachinePrecision], Infinity], N[(N[(t / t$95$1), $MachinePrecision] + N[(t$95$2 / t$95$1), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 84.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)}\\ \mathbf{if}\;t_1 \leq \infty:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1
         (/
          (+
           t
           (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
          (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))))
   (if (<= t_1 INFINITY) t_1 (+ x (- (/ z y) (/ a (/ y x)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	double tmp;
	if (t_1 <= ((double) INFINITY)) {
		tmp = t_1;
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	double tmp;
	if (t_1 <= Double.POSITIVE_INFINITY) {
		tmp = t_1;
	} else {
		tmp = x + ((z / y) - (a / (y / x)));
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * (b + (y * (y + a)))))))
	tmp = 0
	if t_1 <= math.inf:
		tmp = t_1
	else:
		tmp = x + ((z / y) - (a / (y / x)))
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a))))))))
	tmp = 0.0
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	tmp = 0.0;
	if (t_1 <= Inf)
		tmp = t_1;
	else
		tmp = x + ((z / y) - (a / (y / x)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 81.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -1.85 \cdot 10^{+77}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.3 \cdot 10^{+30}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq -3 \cdot 10^{-42}:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{i + y \cdot \left(c + y \cdot b\right)}\\ \mathbf{elif}\;y \leq 2.7 \cdot 10^{+67}:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)}\\ \mathbf{elif}\;y \leq 3.6 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -1.85e+77)
     t_2
     (if (<= y -1.3e+30)
       t_1
       (if (<= y -3e-42)
         (/
          (+
           t
           (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
          (+ i (* y (+ c (* y b)))))
         (if (<= y 2.7e+67)
           (/
            (+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
            (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
           (if (<= y 3.6e+112) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.85e+77) {
		tmp = t_2;
	} else if (y <= -1.3e+30) {
		tmp = t_1;
	} else if (y <= -3e-42) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	} else if (y <= 2.7e+67) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 3.6e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-1.85d+77)) then
        tmp = t_2
    else if (y <= (-1.3d+30)) then
        tmp = t_1
    else if (y <= (-3d-42)) then
        tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))))
    else if (y <= 2.7d+67) then
        tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / (i + (y * (c + (y * (b + (y * (y + a)))))))
    else if (y <= 3.6d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.85e+77) {
		tmp = t_2;
	} else if (y <= -1.3e+30) {
		tmp = t_1;
	} else if (y <= -3e-42) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	} else if (y <= 2.7e+67) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 3.6e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -1.85e+77:
		tmp = t_2
	elif y <= -1.3e+30:
		tmp = t_1
	elif y <= -3e-42:
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))))
	elif y <= 2.7e+67:
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * (y + a)))))))
	elif y <= 3.6e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -1.85e+77)
		tmp = t_2;
	elseif (y <= -1.3e+30)
		tmp = t_1;
	elseif (y <= -3e-42)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(i + Float64(y * Float64(c + Float64(y * b)))));
	elseif (y <= 2.7e+67)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a))))))));
	elseif (y <= 3.6e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -1.85e+77)
		tmp = t_2;
	elseif (y <= -1.3e+30)
		tmp = t_1;
	elseif (y <= -3e-42)
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	elseif (y <= 2.7e+67)
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	elseif (y <= 3.6e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.85e+77], t$95$2, If[LessEqual[y, -1.3e+30], t$95$1, If[LessEqual[y, -3e-42], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.7e+67], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.6e+112], t$95$1, t$95$2]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 77.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -3.6 \cdot 10^{+81}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.25 \cdot 10^{+28}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 6 \cdot 10^{-100}:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{i + y \cdot \left(c + y \cdot b\right)}\\ \mathbf{elif}\;y \leq 3.5 \cdot 10^{+67}:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)}\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{+113}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -3.6e+81)
     t_2
     (if (<= y -1.25e+28)
       t_1
       (if (<= y 6e-100)
         (/
          (+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
          (+ i (* y (+ c (* y b)))))
         (if (<= y 3.5e+67)
           (/
            (+ t (* y (+ 230661.510616 (* y 27464.7644705))))
            (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
           (if (<= y 1.2e+113) t_1 t_2)))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -3.6e+81) {
		tmp = t_2;
	} else if (y <= -1.25e+28) {
		tmp = t_1;
	} else if (y <= 6e-100) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * b))));
	} else if (y <= 3.5e+67) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 1.2e+113) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-3.6d+81)) then
        tmp = t_2
    else if (y <= (-1.25d+28)) then
        tmp = t_1
    else if (y <= 6d-100) then
        tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / (i + (y * (c + (y * b))))
    else if (y <= 3.5d+67) then
        tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / (i + (y * (c + (y * (b + (y * (y + a)))))))
    else if (y <= 1.2d+113) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -3.6e+81) {
		tmp = t_2;
	} else if (y <= -1.25e+28) {
		tmp = t_1;
	} else if (y <= 6e-100) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * b))));
	} else if (y <= 3.5e+67) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 1.2e+113) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -3.6e+81:
		tmp = t_2
	elif y <= -1.25e+28:
		tmp = t_1
	elif y <= 6e-100:
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * b))))
	elif y <= 3.5e+67:
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * (b + (y * (y + a)))))))
	elif y <= 1.2e+113:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -3.6e+81)
		tmp = t_2;
	elseif (y <= -1.25e+28)
		tmp = t_1;
	elseif (y <= 6e-100)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(i + Float64(y * Float64(c + Float64(y * b)))));
	elseif (y <= 3.5e+67)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a))))))));
	elseif (y <= 1.2e+113)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -3.6e+81)
		tmp = t_2;
	elseif (y <= -1.25e+28)
		tmp = t_1;
	elseif (y <= 6e-100)
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * b))));
	elseif (y <= 3.5e+67)
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	elseif (y <= 1.2e+113)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.6e+81], t$95$2, If[LessEqual[y, -1.25e+28], t$95$1, If[LessEqual[y, 6e-100], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.5e+67], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.2e+113], t$95$1, t$95$2]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 80.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -2.35 \cdot 10^{+82}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -6.2 \cdot 10^{+28}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 350000:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{i + y \cdot \left(c + y \cdot b\right)}\\ \mathbf{elif}\;y \leq 1.02 \cdot 10^{+114}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -2.35e+82)
     t_2
     (if (<= y -6.2e+28)
       t_1
       (if (<= y 350000.0)
         (/
          (+
           t
           (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
          (+ i (* y (+ c (* y b)))))
         (if (<= y 1.02e+114) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -2.35e+82) {
		tmp = t_2;
	} else if (y <= -6.2e+28) {
		tmp = t_1;
	} else if (y <= 350000.0) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	} else if (y <= 1.02e+114) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-2.35d+82)) then
        tmp = t_2
    else if (y <= (-6.2d+28)) then
        tmp = t_1
    else if (y <= 350000.0d0) then
        tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))))
    else if (y <= 1.02d+114) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -2.35e+82) {
		tmp = t_2;
	} else if (y <= -6.2e+28) {
		tmp = t_1;
	} else if (y <= 350000.0) {
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	} else if (y <= 1.02e+114) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -2.35e+82:
		tmp = t_2
	elif y <= -6.2e+28:
		tmp = t_1
	elif y <= 350000.0:
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))))
	elif y <= 1.02e+114:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -2.35e+82)
		tmp = t_2;
	elseif (y <= -6.2e+28)
		tmp = t_1;
	elseif (y <= 350000.0)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(i + Float64(y * Float64(c + Float64(y * b)))));
	elseif (y <= 1.02e+114)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -2.35e+82)
		tmp = t_2;
	elseif (y <= -6.2e+28)
		tmp = t_1;
	elseif (y <= 350000.0)
		tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + (y * (c + (y * b))));
	elseif (y <= 1.02e+114)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.35e+82], t$95$2, If[LessEqual[y, -6.2e+28], t$95$1, If[LessEqual[y, 350000.0], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.02e+114], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 76.8% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -2.4 \cdot 10^{+77}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -4.2 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 3 \cdot 10^{+14}:\\ \;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)}\\ \mathbf{elif}\;y \leq 5.5 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -2.4e+77)
     t_2
     (if (<= y -4.2e+23)
       t_1
       (if (<= y 3e+14)
         (/
          (+ t (* y 230661.510616))
          (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
         (if (<= y 5.5e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -2.4e+77) {
		tmp = t_2;
	} else if (y <= -4.2e+23) {
		tmp = t_1;
	} else if (y <= 3e+14) {
		tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 5.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-2.4d+77)) then
        tmp = t_2
    else if (y <= (-4.2d+23)) then
        tmp = t_1
    else if (y <= 3d+14) then
        tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + (y * (b + (y * (y + a)))))))
    else if (y <= 5.5d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -2.4e+77) {
		tmp = t_2;
	} else if (y <= -4.2e+23) {
		tmp = t_1;
	} else if (y <= 3e+14) {
		tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 5.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -2.4e+77:
		tmp = t_2
	elif y <= -4.2e+23:
		tmp = t_1
	elif y <= 3e+14:
		tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * (y + a)))))))
	elif y <= 5.5e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -2.4e+77)
		tmp = t_2;
	elseif (y <= -4.2e+23)
		tmp = t_1;
	elseif (y <= 3e+14)
		tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a))))))));
	elseif (y <= 5.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -2.4e+77)
		tmp = t_2;
	elseif (y <= -4.2e+23)
		tmp = t_1;
	elseif (y <= 3e+14)
		tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * (y + a)))))));
	elseif (y <= 5.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.4e+77], t$95$2, If[LessEqual[y, -4.2e+23], t$95$1, If[LessEqual[y, 3e+14], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 75.3% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -1.12 \cdot 10^{+77}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -1.25 \cdot 10^{+25}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 225000:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{i + y \cdot \left(c + y \cdot b\right)}\\ \mathbf{elif}\;y \leq 9.5 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -1.12e+77)
     t_2
     (if (<= y -1.25e+25)
       t_1
       (if (<= y 225000.0)
         (/
          (+ t (* y (+ 230661.510616 (* y 27464.7644705))))
          (+ i (* y (+ c (* y b)))))
         (if (<= y 9.5e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.12e+77) {
		tmp = t_2;
	} else if (y <= -1.25e+25) {
		tmp = t_1;
	} else if (y <= 225000.0) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))));
	} else if (y <= 9.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-1.12d+77)) then
        tmp = t_2
    else if (y <= (-1.25d+25)) then
        tmp = t_1
    else if (y <= 225000.0d0) then
        tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / (i + (y * (c + (y * b))))
    else if (y <= 9.5d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.12e+77) {
		tmp = t_2;
	} else if (y <= -1.25e+25) {
		tmp = t_1;
	} else if (y <= 225000.0) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))));
	} else if (y <= 9.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -1.12e+77:
		tmp = t_2
	elif y <= -1.25e+25:
		tmp = t_1
	elif y <= 225000.0:
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))))
	elif y <= 9.5e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -1.12e+77)
		tmp = t_2;
	elseif (y <= -1.25e+25)
		tmp = t_1;
	elseif (y <= 225000.0)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(i + Float64(y * Float64(c + Float64(y * b)))));
	elseif (y <= 9.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -1.12e+77)
		tmp = t_2;
	elseif (y <= -1.25e+25)
		tmp = t_1;
	elseif (y <= 225000.0)
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))));
	elseif (y <= 9.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.12e+77], t$95$2, If[LessEqual[y, -1.25e+25], t$95$1, If[LessEqual[y, 225000.0], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.5e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 66.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -1.06 \cdot 10^{+77}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 72000:\\ \;\;\;\;\frac{t}{i + y \cdot c} + 230661.510616 \cdot \frac{y}{i}\\ \mathbf{elif}\;y \leq 9.5 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -1.06e+77)
     t_2
     (if (<= y -2.2e+23)
       t_1
       (if (<= y 72000.0)
         (+ (/ t (+ i (* y c))) (* 230661.510616 (/ y i)))
         (if (<= y 9.5e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.06e+77) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 72000.0) {
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	} else if (y <= 9.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-1.06d+77)) then
        tmp = t_2
    else if (y <= (-2.2d+23)) then
        tmp = t_1
    else if (y <= 72000.0d0) then
        tmp = (t / (i + (y * c))) + (230661.510616d0 * (y / i))
    else if (y <= 9.5d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.06e+77) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 72000.0) {
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	} else if (y <= 9.5e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -1.06e+77:
		tmp = t_2
	elif y <= -2.2e+23:
		tmp = t_1
	elif y <= 72000.0:
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i))
	elif y <= 9.5e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -1.06e+77)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 72000.0)
		tmp = Float64(Float64(t / Float64(i + Float64(y * c))) + Float64(230661.510616 * Float64(y / i)));
	elseif (y <= 9.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -1.06e+77)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 72000.0)
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	elseif (y <= 9.5e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.06e+77], t$95$2, If[LessEqual[y, -2.2e+23], t$95$1, If[LessEqual[y, 72000.0], N[(N[(t / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(230661.510616 * N[(y / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.5e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 69.5% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{27464.7644705}{y \cdot a} + \left(\frac{z}{a} + \frac{x}{\frac{a}{y}}\right)\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -4 \cdot 10^{+83}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.6 \cdot 10^{+26}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 2.2 \cdot 10^{+14}:\\ \;\;\;\;\frac{t}{i + y \cdot \left(c + y \cdot \left(b + y \cdot \left(y + a\right)\right)\right)}\\ \mathbf{elif}\;y \leq 3.3 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ 27464.7644705 (* y a)) (+ (/ z a) (/ x (/ a y)))))
        (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -4e+83)
     t_2
     (if (<= y -2.6e+26)
       t_1
       (if (<= y 2.2e+14)
         (/ t (+ i (* y (+ c (* y (+ b (* y (+ y a))))))))
         (if (<= y 3.3e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -4e+83) {
		tmp = t_2;
	} else if (y <= -2.6e+26) {
		tmp = t_1;
	} else if (y <= 2.2e+14) {
		tmp = t / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 3.3e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (27464.7644705d0 / (y * a)) + ((z / a) + (x / (a / y)))
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-4d+83)) then
        tmp = t_2
    else if (y <= (-2.6d+26)) then
        tmp = t_1
    else if (y <= 2.2d+14) then
        tmp = t / (i + (y * (c + (y * (b + (y * (y + a)))))))
    else if (y <= 3.3d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -4e+83) {
		tmp = t_2;
	} else if (y <= -2.6e+26) {
		tmp = t_1;
	} else if (y <= 2.2e+14) {
		tmp = t / (i + (y * (c + (y * (b + (y * (y + a)))))));
	} else if (y <= 3.3e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)))
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -4e+83:
		tmp = t_2
	elif y <= -2.6e+26:
		tmp = t_1
	elif y <= 2.2e+14:
		tmp = t / (i + (y * (c + (y * (b + (y * (y + a)))))))
	elif y <= 3.3e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(27464.7644705 / Float64(y * a)) + Float64(Float64(z / a) + Float64(x / Float64(a / y))))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -4e+83)
		tmp = t_2;
	elseif (y <= -2.6e+26)
		tmp = t_1;
	elseif (y <= 2.2e+14)
		tmp = Float64(t / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * Float64(y + a))))))));
	elseif (y <= 3.3e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (27464.7644705 / (y * a)) + ((z / a) + (x / (a / y)));
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -4e+83)
		tmp = t_2;
	elseif (y <= -2.6e+26)
		tmp = t_1;
	elseif (y <= 2.2e+14)
		tmp = t / (i + (y * (c + (y * (b + (y * (y + a)))))));
	elseif (y <= 3.3e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(27464.7644705 / N[(y * a), $MachinePrecision]), $MachinePrecision] + N[(N[(z / a), $MachinePrecision] + N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4e+83], t$95$2, If[LessEqual[y, -2.6e+26], t$95$1, If[LessEqual[y, 2.2e+14], N[(t / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 61.4% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{a} + \frac{y \cdot x}{a}\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -3.55 \cdot 10^{+80}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 98000:\\ \;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\ \mathbf{elif}\;y \leq 2.05 \cdot 10^{+113}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ z a) (/ (* y x) a))) (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -3.55e+80)
     t_2
     (if (<= y -2.2e+23)
       t_1
       (if (<= y 98000.0)
         (/ (+ t (* y 230661.510616)) i)
         (if (<= y 2.05e+113) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -3.55e+80) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 98000.0) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 2.05e+113) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (z / a) + ((y * x) / a)
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-3.55d+80)) then
        tmp = t_2
    else if (y <= (-2.2d+23)) then
        tmp = t_1
    else if (y <= 98000.0d0) then
        tmp = (t + (y * 230661.510616d0)) / i
    else if (y <= 2.05d+113) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -3.55e+80) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 98000.0) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 2.05e+113) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (z / a) + ((y * x) / a)
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -3.55e+80:
		tmp = t_2
	elif y <= -2.2e+23:
		tmp = t_1
	elif y <= 98000.0:
		tmp = (t + (y * 230661.510616)) / i
	elif y <= 2.05e+113:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(z / a) + Float64(Float64(y * x) / a))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -3.55e+80)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 98000.0)
		tmp = Float64(Float64(t + Float64(y * 230661.510616)) / i);
	elseif (y <= 2.05e+113)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (z / a) + ((y * x) / a);
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -3.55e+80)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 98000.0)
		tmp = (t + (y * 230661.510616)) / i;
	elseif (y <= 2.05e+113)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(z / a), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.55e+80], t$95$2, If[LessEqual[y, -2.2e+23], t$95$1, If[LessEqual[y, 98000.0], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], If[LessEqual[y, 2.05e+113], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 61.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{a} + \frac{y \cdot x}{a}\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -7 \cdot 10^{+78}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.7 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 118000:\\ \;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{i}\\ \mathbf{elif}\;y \leq 7.8 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ z a) (/ (* y x) a))) (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -7e+78)
     t_2
     (if (<= y -2.7e+23)
       t_1
       (if (<= y 118000.0)
         (/ (+ t (* y (+ 230661.510616 (* y 27464.7644705)))) i)
         (if (<= y 7.8e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -7e+78) {
		tmp = t_2;
	} else if (y <= -2.7e+23) {
		tmp = t_1;
	} else if (y <= 118000.0) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / i;
	} else if (y <= 7.8e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (z / a) + ((y * x) / a)
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-7d+78)) then
        tmp = t_2
    else if (y <= (-2.7d+23)) then
        tmp = t_1
    else if (y <= 118000.0d0) then
        tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / i
    else if (y <= 7.8d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -7e+78) {
		tmp = t_2;
	} else if (y <= -2.7e+23) {
		tmp = t_1;
	} else if (y <= 118000.0) {
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / i;
	} else if (y <= 7.8e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (z / a) + ((y * x) / a)
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -7e+78:
		tmp = t_2
	elif y <= -2.7e+23:
		tmp = t_1
	elif y <= 118000.0:
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / i
	elif y <= 7.8e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(z / a) + Float64(Float64(y * x) / a))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -7e+78)
		tmp = t_2;
	elseif (y <= -2.7e+23)
		tmp = t_1;
	elseif (y <= 118000.0)
		tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / i);
	elseif (y <= 7.8e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (z / a) + ((y * x) / a);
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -7e+78)
		tmp = t_2;
	elseif (y <= -2.7e+23)
		tmp = t_1;
	elseif (y <= 118000.0)
		tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / i;
	elseif (y <= 7.8e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(z / a), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7e+78], t$95$2, If[LessEqual[y, -2.7e+23], t$95$1, If[LessEqual[y, 118000.0], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], If[LessEqual[y, 7.8e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 65.9% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{a} + \frac{y \cdot x}{a}\\ t_2 := x + \left(\frac{z}{y} - \frac{a}{\frac{y}{x}}\right)\\ \mathbf{if}\;y \leq -1.42 \cdot 10^{+76}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 70000:\\ \;\;\;\;\frac{t}{i + y \cdot c} + 230661.510616 \cdot \frac{y}{i}\\ \mathbf{elif}\;y \leq 3.3 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ z a) (/ (* y x) a))) (t_2 (+ x (- (/ z y) (/ a (/ y x))))))
   (if (<= y -1.42e+76)
     t_2
     (if (<= y -2.2e+23)
       t_1
       (if (<= y 70000.0)
         (+ (/ t (+ i (* y c))) (* 230661.510616 (/ y i)))
         (if (<= y 3.3e+112) t_1 t_2))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.42e+76) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 70000.0) {
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	} else if (y <= 3.3e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_1 = (z / a) + ((y * x) / a)
    t_2 = x + ((z / y) - (a / (y / x)))
    if (y <= (-1.42d+76)) then
        tmp = t_2
    else if (y <= (-2.2d+23)) then
        tmp = t_1
    else if (y <= 70000.0d0) then
        tmp = (t / (i + (y * c))) + (230661.510616d0 * (y / i))
    else if (y <= 3.3d+112) then
        tmp = t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double t_2 = x + ((z / y) - (a / (y / x)));
	double tmp;
	if (y <= -1.42e+76) {
		tmp = t_2;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 70000.0) {
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	} else if (y <= 3.3e+112) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (z / a) + ((y * x) / a)
	t_2 = x + ((z / y) - (a / (y / x)))
	tmp = 0
	if y <= -1.42e+76:
		tmp = t_2
	elif y <= -2.2e+23:
		tmp = t_1
	elif y <= 70000.0:
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i))
	elif y <= 3.3e+112:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(z / a) + Float64(Float64(y * x) / a))
	t_2 = Float64(x + Float64(Float64(z / y) - Float64(a / Float64(y / x))))
	tmp = 0.0
	if (y <= -1.42e+76)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 70000.0)
		tmp = Float64(Float64(t / Float64(i + Float64(y * c))) + Float64(230661.510616 * Float64(y / i)));
	elseif (y <= 3.3e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (z / a) + ((y * x) / a);
	t_2 = x + ((z / y) - (a / (y / x)));
	tmp = 0.0;
	if (y <= -1.42e+76)
		tmp = t_2;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 70000.0)
		tmp = (t / (i + (y * c))) + (230661.510616 * (y / i));
	elseif (y <= 3.3e+112)
		tmp = t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(z / a), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a / N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.42e+76], t$95$2, If[LessEqual[y, -2.2e+23], t$95$1, If[LessEqual[y, 70000.0], N[(N[(t / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(230661.510616 * N[(y / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+112], t$95$1, t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 55.3% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{z}{a} + \frac{y \cdot x}{a}\\ \mathbf{if}\;y \leq -4.5 \cdot 10^{+106}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -2.2 \cdot 10^{+23}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 145000:\\ \;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\ \mathbf{elif}\;y \leq 4.2 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (+ (/ z a) (/ (* y x) a))))
   (if (<= y -4.5e+106)
     x
     (if (<= y -2.2e+23)
       t_1
       (if (<= y 145000.0)
         (/ (+ t (* y 230661.510616)) i)
         (if (<= y 4.2e+112) t_1 x))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double tmp;
	if (y <= -4.5e+106) {
		tmp = x;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 145000.0) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 4.2e+112) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (z / a) + ((y * x) / a)
    if (y <= (-4.5d+106)) then
        tmp = x
    else if (y <= (-2.2d+23)) then
        tmp = t_1
    else if (y <= 145000.0d0) then
        tmp = (t + (y * 230661.510616d0)) / i
    else if (y <= 4.2d+112) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = (z / a) + ((y * x) / a);
	double tmp;
	if (y <= -4.5e+106) {
		tmp = x;
	} else if (y <= -2.2e+23) {
		tmp = t_1;
	} else if (y <= 145000.0) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 4.2e+112) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = (z / a) + ((y * x) / a)
	tmp = 0
	if y <= -4.5e+106:
		tmp = x
	elif y <= -2.2e+23:
		tmp = t_1
	elif y <= 145000.0:
		tmp = (t + (y * 230661.510616)) / i
	elif y <= 4.2e+112:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(Float64(z / a) + Float64(Float64(y * x) / a))
	tmp = 0.0
	if (y <= -4.5e+106)
		tmp = x;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 145000.0)
		tmp = Float64(Float64(t + Float64(y * 230661.510616)) / i);
	elseif (y <= 4.2e+112)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = (z / a) + ((y * x) / a);
	tmp = 0.0;
	if (y <= -4.5e+106)
		tmp = x;
	elseif (y <= -2.2e+23)
		tmp = t_1;
	elseif (y <= 145000.0)
		tmp = (t + (y * 230661.510616)) / i;
	elseif (y <= 4.2e+112)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(z / a), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.5e+106], x, If[LessEqual[y, -2.2e+23], t$95$1, If[LessEqual[y, 145000.0], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], If[LessEqual[y, 4.2e+112], t$95$1, x]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 50.0% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{x}{\frac{a}{y}}\\ \mathbf{if}\;y \leq -1.2 \cdot 10^{+87}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -6 \cdot 10^{+21}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.05 \cdot 10^{-66}:\\ \;\;\;\;\frac{t}{i}\\ \mathbf{elif}\;y \leq 7.5 \cdot 10^{+112}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (/ x (/ a y))))
   (if (<= y -1.2e+87)
     x
     (if (<= y -6e+21)
       t_1
       (if (<= y 1.05e-66) (/ t i) (if (<= y 7.5e+112) t_1 x))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = x / (a / y);
	double tmp;
	if (y <= -1.2e+87) {
		tmp = x;
	} else if (y <= -6e+21) {
		tmp = t_1;
	} else if (y <= 1.05e-66) {
		tmp = t / i;
	} else if (y <= 7.5e+112) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = x / (a / y)
    if (y <= (-1.2d+87)) then
        tmp = x
    else if (y <= (-6d+21)) then
        tmp = t_1
    else if (y <= 1.05d-66) then
        tmp = t / i
    else if (y <= 7.5d+112) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = x / (a / y);
	double tmp;
	if (y <= -1.2e+87) {
		tmp = x;
	} else if (y <= -6e+21) {
		tmp = t_1;
	} else if (y <= 1.05e-66) {
		tmp = t / i;
	} else if (y <= 7.5e+112) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = x / (a / y)
	tmp = 0
	if y <= -1.2e+87:
		tmp = x
	elif y <= -6e+21:
		tmp = t_1
	elif y <= 1.05e-66:
		tmp = t / i
	elif y <= 7.5e+112:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(x / Float64(a / y))
	tmp = 0.0
	if (y <= -1.2e+87)
		tmp = x;
	elseif (y <= -6e+21)
		tmp = t_1;
	elseif (y <= 1.05e-66)
		tmp = Float64(t / i);
	elseif (y <= 7.5e+112)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = x / (a / y);
	tmp = 0.0;
	if (y <= -1.2e+87)
		tmp = x;
	elseif (y <= -6e+21)
		tmp = t_1;
	elseif (y <= 1.05e-66)
		tmp = t / i;
	elseif (y <= 7.5e+112)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(x / N[(a / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.2e+87], x, If[LessEqual[y, -6e+21], t$95$1, If[LessEqual[y, 1.05e-66], N[(t / i), $MachinePrecision], If[LessEqual[y, 7.5e+112], t$95$1, x]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 50.0% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{y}{\frac{a}{x}}\\ \mathbf{if}\;y \leq -1.72 \cdot 10^{+84}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -6.1 \cdot 10^{+21}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.05 \cdot 10^{-66}:\\ \;\;\;\;\frac{t}{i}\\ \mathbf{elif}\;y \leq 2.9 \cdot 10^{+115}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (/ y (/ a x))))
   (if (<= y -1.72e+84)
     x
     (if (<= y -6.1e+21)
       t_1
       (if (<= y 1.05e-66) (/ t i) (if (<= y 2.9e+115) t_1 x))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = y / (a / x);
	double tmp;
	if (y <= -1.72e+84) {
		tmp = x;
	} else if (y <= -6.1e+21) {
		tmp = t_1;
	} else if (y <= 1.05e-66) {
		tmp = t / i;
	} else if (y <= 2.9e+115) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = y / (a / x)
    if (y <= (-1.72d+84)) then
        tmp = x
    else if (y <= (-6.1d+21)) then
        tmp = t_1
    else if (y <= 1.05d-66) then
        tmp = t / i
    else if (y <= 2.9d+115) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = y / (a / x);
	double tmp;
	if (y <= -1.72e+84) {
		tmp = x;
	} else if (y <= -6.1e+21) {
		tmp = t_1;
	} else if (y <= 1.05e-66) {
		tmp = t / i;
	} else if (y <= 2.9e+115) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = y / (a / x)
	tmp = 0
	if y <= -1.72e+84:
		tmp = x
	elif y <= -6.1e+21:
		tmp = t_1
	elif y <= 1.05e-66:
		tmp = t / i
	elif y <= 2.9e+115:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(y / Float64(a / x))
	tmp = 0.0
	if (y <= -1.72e+84)
		tmp = x;
	elseif (y <= -6.1e+21)
		tmp = t_1;
	elseif (y <= 1.05e-66)
		tmp = Float64(t / i);
	elseif (y <= 2.9e+115)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = y / (a / x);
	tmp = 0.0;
	if (y <= -1.72e+84)
		tmp = x;
	elseif (y <= -6.1e+21)
		tmp = t_1;
	elseif (y <= 1.05e-66)
		tmp = t / i;
	elseif (y <= 2.9e+115)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.72e+84], x, If[LessEqual[y, -6.1e+21], t$95$1, If[LessEqual[y, 1.05e-66], N[(t / i), $MachinePrecision], If[LessEqual[y, 2.9e+115], t$95$1, x]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 53.7% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{y}{\frac{a}{x}}\\ \mathbf{if}\;y \leq -1.45 \cdot 10^{+84}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -7.5 \cdot 10^{+21}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y \leq 1.2 \cdot 10^{-40}:\\ \;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\ \mathbf{elif}\;y \leq 2.9 \cdot 10^{+115}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (let* ((t_1 (/ y (/ a x))))
   (if (<= y -1.45e+84)
     x
     (if (<= y -7.5e+21)
       t_1
       (if (<= y 1.2e-40)
         (/ (+ t (* y 230661.510616)) i)
         (if (<= y 2.9e+115) t_1 x))))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = y / (a / x);
	double tmp;
	if (y <= -1.45e+84) {
		tmp = x;
	} else if (y <= -7.5e+21) {
		tmp = t_1;
	} else if (y <= 1.2e-40) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 2.9e+115) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: t_1
    real(8) :: tmp
    t_1 = y / (a / x)
    if (y <= (-1.45d+84)) then
        tmp = x
    else if (y <= (-7.5d+21)) then
        tmp = t_1
    else if (y <= 1.2d-40) then
        tmp = (t + (y * 230661.510616d0)) / i
    else if (y <= 2.9d+115) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double t_1 = y / (a / x);
	double tmp;
	if (y <= -1.45e+84) {
		tmp = x;
	} else if (y <= -7.5e+21) {
		tmp = t_1;
	} else if (y <= 1.2e-40) {
		tmp = (t + (y * 230661.510616)) / i;
	} else if (y <= 2.9e+115) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	t_1 = y / (a / x)
	tmp = 0
	if y <= -1.45e+84:
		tmp = x
	elif y <= -7.5e+21:
		tmp = t_1
	elif y <= 1.2e-40:
		tmp = (t + (y * 230661.510616)) / i
	elif y <= 2.9e+115:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	t_1 = Float64(y / Float64(a / x))
	tmp = 0.0
	if (y <= -1.45e+84)
		tmp = x;
	elseif (y <= -7.5e+21)
		tmp = t_1;
	elseif (y <= 1.2e-40)
		tmp = Float64(Float64(t + Float64(y * 230661.510616)) / i);
	elseif (y <= 2.9e+115)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	t_1 = y / (a / x);
	tmp = 0.0;
	if (y <= -1.45e+84)
		tmp = x;
	elseif (y <= -7.5e+21)
		tmp = t_1;
	elseif (y <= 1.2e-40)
		tmp = (t + (y * 230661.510616)) / i;
	elseif (y <= 2.9e+115)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(y / N[(a / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.45e+84], x, If[LessEqual[y, -7.5e+21], t$95$1, If[LessEqual[y, 1.2e-40], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], If[LessEqual[y, 2.9e+115], t$95$1, x]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 19: 50.6% accurate, 3.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -1.75 \cdot 10^{+78}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq -9.2 \cdot 10^{+25}:\\ \;\;\;\;\frac{z}{a}\\ \mathbf{elif}\;y \leq 180000:\\ \;\;\;\;\frac{t}{i}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (<= y -1.75e+78)
   x
   (if (<= y -9.2e+25) (/ z a) (if (<= y 180000.0) (/ t i) x))))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (y <= -1.75e+78) {
		tmp = x;
	} else if (y <= -9.2e+25) {
		tmp = z / a;
	} else if (y <= 180000.0) {
		tmp = t / i;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if (y <= (-1.75d+78)) then
        tmp = x
    else if (y <= (-9.2d+25)) then
        tmp = z / a
    else if (y <= 180000.0d0) then
        tmp = t / i
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (y <= -1.75e+78) {
		tmp = x;
	} else if (y <= -9.2e+25) {
		tmp = z / a;
	} else if (y <= 180000.0) {
		tmp = t / i;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if y <= -1.75e+78:
		tmp = x
	elif y <= -9.2e+25:
		tmp = z / a
	elif y <= 180000.0:
		tmp = t / i
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (y <= -1.75e+78)
		tmp = x;
	elseif (y <= -9.2e+25)
		tmp = Float64(z / a);
	elseif (y <= 180000.0)
		tmp = Float64(t / i);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (y <= -1.75e+78)
		tmp = x;
	elseif (y <= -9.2e+25)
		tmp = z / a;
	elseif (y <= 180000.0)
		tmp = t / i;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -1.75e+78], x, If[LessEqual[y, -9.2e+25], N[(z / a), $MachinePrecision], If[LessEqual[y, 180000.0], N[(t / i), $MachinePrecision], x]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 20: 50.4% accurate, 4.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -3.3 \cdot 10^{+71}:\\ \;\;\;\;x\\ \mathbf{elif}\;y \leq 135000:\\ \;\;\;\;\frac{t}{i}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z t a b c i)
 :precision binary64
 (if (<= y -3.3e+71) x (if (<= y 135000.0) (/ t i) x)))

C

double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (y <= -3.3e+71) {
		tmp = x;
	} else if (y <= 135000.0) {
		tmp = t / i;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z, t, a, b, c, i)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: i
    real(8) :: tmp
    if (y <= (-3.3d+71)) then
        tmp = x
    else if (y <= 135000.0d0) then
        tmp = t / i
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
	double tmp;
	if (y <= -3.3e+71) {
		tmp = x;
	} else if (y <= 135000.0) {
		tmp = t / i;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z, t, a, b, c, i):
	tmp = 0
	if y <= -3.3e+71:
		tmp = x
	elif y <= 135000.0:
		tmp = t / i
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z, t, a, b, c, i)
	tmp = 0.0
	if (y <= -3.3e+71)
		tmp = x;
	elseif (y <= 135000.0)
		tmp = Float64(t / i);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z, t, a, b, c, i)
	tmp = 0.0;
	if (y <= -3.3e+71)
		tmp = x;
	elseif (y <= 135000.0)
		tmp = t / i;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.3e+71], x, If[LessEqual[y, 135000.0], N[(t / i), $MachinePrecision], x]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 21: 25.4% accurate, 33.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2023343 
(FPCore (x y z t a b c i)
  :name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2"
  :precision binary64
  (/ (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))