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

Percentage Accurate: 68.5% → 99.8%

Time: 17.8s

Alternatives: 24

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))

C

double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function

Java

public static double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Python

def code(x, y):
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))

Julia

function code(x, y)
	return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
end

Wolfram

code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 68.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))

C

double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function

Java

public static double code(double x, double y) {
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}

Python

def code(x, y):
	return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))

Julia

function code(x, y)
	return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0)))
end

MATLAB

function tmp = code(x, y)
	tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
end

Wolfram

code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{y}{y + x} \cdot \frac{x}{y + \left(x + 1\right)}}{y + x} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (/ (* (/ y (+ y x)) (/ x (+ y (+ x 1.0)))) (+ y x)))

C

double code(double x, double y) {
	return ((y / (y + x)) * (x / (y + (x + 1.0)))) / (y + x);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = ((y / (y + x)) * (x / (y + (x + 1.0d0)))) / (y + x)
end function

Java

public static double code(double x, double y) {
	return ((y / (y + x)) * (x / (y + (x + 1.0)))) / (y + x);
}

Python

def code(x, y):
	return ((y / (y + x)) * (x / (y + (x + 1.0)))) / (y + x)

Julia

function code(x, y)
	return Float64(Float64(Float64(y / Float64(y + x)) * Float64(x / Float64(y + Float64(x + 1.0)))) / Float64(y + x))
end

MATLAB

function tmp = code(x, y)
	tmp = ((y / (y + x)) * (x / (y + (x + 1.0)))) / (y + x);
end

Wolfram

code[x_, y_] := N[(N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 2: 70.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{elif}\;x \leq -3100000000:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq -2.3 \cdot 10^{-13}:\\ \;\;\;\;\frac{1}{\left(x + 1\right) \cdot \frac{y + x}{y}}\\ \mathbf{elif}\;x \leq -6.4 \cdot 10^{-161}:\\ \;\;\;\;t_0 \cdot \frac{x}{y + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ y (* (+ y x) (+ y x)))))
   (if (<= x -1.35e+154)
     (/ (/ y (+ y x)) (+ x (- y (- -1.0 y))))
     (if (<= x -3100000000.0)
       t_0
       (if (<= x -2.3e-13)
         (/ 1.0 (* (+ x 1.0) (/ (+ y x) y)))
         (if (<= x -6.4e-161)
           (* t_0 (/ x (+ y 1.0)))
           (/ (/ x (+ y (+ x 1.0))) (+ y x))))))))

C

double code(double x, double y) {
	double t_0 = y / ((y + x) * (y + x));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	} else if (x <= -3100000000.0) {
		tmp = t_0;
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else if (x <= -6.4e-161) {
		tmp = t_0 * (x / (y + 1.0));
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = y / ((y + x) * (y + x))
    if (x <= (-1.35d+154)) then
        tmp = (y / (y + x)) / (x + (y - ((-1.0d0) - y)))
    else if (x <= (-3100000000.0d0)) then
        tmp = t_0
    else if (x <= (-2.3d-13)) then
        tmp = 1.0d0 / ((x + 1.0d0) * ((y + x) / y))
    else if (x <= (-6.4d-161)) then
        tmp = t_0 * (x / (y + 1.0d0))
    else
        tmp = (x / (y + (x + 1.0d0))) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = y / ((y + x) * (y + x));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	} else if (x <= -3100000000.0) {
		tmp = t_0;
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else if (x <= -6.4e-161) {
		tmp = t_0 * (x / (y + 1.0));
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = y / ((y + x) * (y + x))
	tmp = 0
	if x <= -1.35e+154:
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)))
	elif x <= -3100000000.0:
		tmp = t_0
	elif x <= -2.3e-13:
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y))
	elif x <= -6.4e-161:
		tmp = t_0 * (x / (y + 1.0))
	else:
		tmp = (x / (y + (x + 1.0))) / (y + x)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(y / Float64(Float64(y + x) * Float64(y + x)))
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y - Float64(-1.0 - y))));
	elseif (x <= -3100000000.0)
		tmp = t_0;
	elseif (x <= -2.3e-13)
		tmp = Float64(1.0 / Float64(Float64(x + 1.0) * Float64(Float64(y + x) / y)));
	elseif (x <= -6.4e-161)
		tmp = Float64(t_0 * Float64(x / Float64(y + 1.0)));
	else
		tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = y / ((y + x) * (y + x));
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	elseif (x <= -3100000000.0)
		tmp = t_0;
	elseif (x <= -2.3e-13)
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	elseif (x <= -6.4e-161)
		tmp = t_0 * (x / (y + 1.0));
	else
		tmp = (x / (y + (x + 1.0))) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+154], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3100000000.0], t$95$0, If[LessEqual[x, -2.3e-13], N[(1.0 / N[(N[(x + 1.0), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.4e-161], N[(t$95$0 * N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 3: 82.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{y + x}}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{elif}\;x \leq -350000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -2.3 \cdot 10^{-13}:\\ \;\;\;\;\frac{1}{\left(x + 1\right) \cdot \frac{y + x}{y}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{y}{\left(y + x\right) \cdot \frac{y + 1}{x}}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -1.35e+154)
   (/ (/ y (+ y x)) (+ x (- y (- -1.0 y))))
   (if (<= x -350000000.0)
     (/ y (* (+ y x) (+ y x)))
     (if (<= x -2.3e-13)
       (/ 1.0 (* (+ x 1.0) (/ (+ y x) y)))
       (/ (/ y (* (+ y x) (/ (+ y 1.0) x))) (+ y x))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	} else if (x <= -350000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else {
		tmp = (y / ((y + x) * ((y + 1.0) / x))) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-1.35d+154)) then
        tmp = (y / (y + x)) / (x + (y - ((-1.0d0) - y)))
    else if (x <= (-350000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-2.3d-13)) then
        tmp = 1.0d0 / ((x + 1.0d0) * ((y + x) / y))
    else
        tmp = (y / ((y + x) * ((y + 1.0d0) / x))) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	} else if (x <= -350000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else {
		tmp = (y / ((y + x) * ((y + 1.0) / x))) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -1.35e+154:
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)))
	elif x <= -350000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -2.3e-13:
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y))
	else:
		tmp = (y / ((y + x) * ((y + 1.0) / x))) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y - Float64(-1.0 - y))));
	elseif (x <= -350000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -2.3e-13)
		tmp = Float64(1.0 / Float64(Float64(x + 1.0) * Float64(Float64(y + x) / y)));
	else
		tmp = Float64(Float64(y / Float64(Float64(y + x) * Float64(Float64(y + 1.0) / x))) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = (y / (y + x)) / (x + (y - (-1.0 - y)));
	elseif (x <= -350000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -2.3e-13)
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	else
		tmp = (y / ((y + x) * ((y + 1.0) / x))) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -1.35e+154], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -350000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.3e-13], N[(1.0 / N[(N[(x + 1.0), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y / N[(N[(y + x), $MachinePrecision] * N[(N[(y + 1.0), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 4: 82.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{y}{y + x}\\ \mathbf{if}\;x \leq -1.55 \cdot 10^{+154}:\\ \;\;\;\;\frac{t_0}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{elif}\;x \leq -1650000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -2.3 \cdot 10^{-13}:\\ \;\;\;\;\frac{1}{\left(x + 1\right) \cdot \frac{y + x}{y}}\\ \mathbf{else}:\\ \;\;\;\;\frac{t_0}{\left(y + x\right) \cdot \frac{y + 1}{x}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ y (+ y x))))
   (if (<= x -1.55e+154)
     (/ t_0 (+ x (- y (- -1.0 y))))
     (if (<= x -1650000000.0)
       (/ y (* (+ y x) (+ y x)))
       (if (<= x -2.3e-13)
         (/ 1.0 (* (+ x 1.0) (/ (+ y x) y)))
         (/ t_0 (* (+ y x) (/ (+ y 1.0) x))))))))

C

double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -1.55e+154) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -1650000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = y / (y + x)
    if (x <= (-1.55d+154)) then
        tmp = t_0 / (x + (y - ((-1.0d0) - y)))
    else if (x <= (-1650000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-2.3d-13)) then
        tmp = 1.0d0 / ((x + 1.0d0) * ((y + x) / y))
    else
        tmp = t_0 / ((y + x) * ((y + 1.0d0) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -1.55e+154) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -1650000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -2.3e-13) {
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = y / (y + x)
	tmp = 0
	if x <= -1.55e+154:
		tmp = t_0 / (x + (y - (-1.0 - y)))
	elif x <= -1650000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -2.3e-13:
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y))
	else:
		tmp = t_0 / ((y + x) * ((y + 1.0) / x))
	return tmp

Julia

function code(x, y)
	t_0 = Float64(y / Float64(y + x))
	tmp = 0.0
	if (x <= -1.55e+154)
		tmp = Float64(t_0 / Float64(x + Float64(y - Float64(-1.0 - y))));
	elseif (x <= -1650000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -2.3e-13)
		tmp = Float64(1.0 / Float64(Float64(x + 1.0) * Float64(Float64(y + x) / y)));
	else
		tmp = Float64(t_0 / Float64(Float64(y + x) * Float64(Float64(y + 1.0) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = y / (y + x);
	tmp = 0.0;
	if (x <= -1.55e+154)
		tmp = t_0 / (x + (y - (-1.0 - y)));
	elseif (x <= -1650000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -2.3e-13)
		tmp = 1.0 / ((x + 1.0) * ((y + x) / y));
	else
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.55e+154], N[(t$95$0 / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1650000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.3e-13], N[(1.0 / N[(N[(x + 1.0), $MachinePrecision] * N[(N[(y + x), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(N[(y + x), $MachinePrecision] * N[(N[(y + 1.0), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 5: 84.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{y}{y + x}\\ \mathbf{if}\;x \leq -5.4 \cdot 10^{+142}:\\ \;\;\;\;\frac{t_0}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{elif}\;x \leq -4.3 \cdot 10^{-15}:\\ \;\;\;\;y \cdot \frac{\frac{x}{\left(y + x\right) \cdot \left(y + \left(x + 1\right)\right)}}{y + x}\\ \mathbf{else}:\\ \;\;\;\;\frac{t_0}{\left(y + x\right) \cdot \frac{y + 1}{x}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ y (+ y x))))
   (if (<= x -5.4e+142)
     (/ t_0 (+ x (- y (- -1.0 y))))
     (if (<= x -4.3e-15)
       (* y (/ (/ x (* (+ y x) (+ y (+ x 1.0)))) (+ y x)))
       (/ t_0 (* (+ y x) (/ (+ y 1.0) x)))))))

C

double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -5.4e+142) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -4.3e-15) {
		tmp = y * ((x / ((y + x) * (y + (x + 1.0)))) / (y + x));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = y / (y + x)
    if (x <= (-5.4d+142)) then
        tmp = t_0 / (x + (y - ((-1.0d0) - y)))
    else if (x <= (-4.3d-15)) then
        tmp = y * ((x / ((y + x) * (y + (x + 1.0d0)))) / (y + x))
    else
        tmp = t_0 / ((y + x) * ((y + 1.0d0) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -5.4e+142) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -4.3e-15) {
		tmp = y * ((x / ((y + x) * (y + (x + 1.0)))) / (y + x));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = y / (y + x)
	tmp = 0
	if x <= -5.4e+142:
		tmp = t_0 / (x + (y - (-1.0 - y)))
	elif x <= -4.3e-15:
		tmp = y * ((x / ((y + x) * (y + (x + 1.0)))) / (y + x))
	else:
		tmp = t_0 / ((y + x) * ((y + 1.0) / x))
	return tmp

Julia

function code(x, y)
	t_0 = Float64(y / Float64(y + x))
	tmp = 0.0
	if (x <= -5.4e+142)
		tmp = Float64(t_0 / Float64(x + Float64(y - Float64(-1.0 - y))));
	elseif (x <= -4.3e-15)
		tmp = Float64(y * Float64(Float64(x / Float64(Float64(y + x) * Float64(y + Float64(x + 1.0)))) / Float64(y + x)));
	else
		tmp = Float64(t_0 / Float64(Float64(y + x) * Float64(Float64(y + 1.0) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = y / (y + x);
	tmp = 0.0;
	if (x <= -5.4e+142)
		tmp = t_0 / (x + (y - (-1.0 - y)));
	elseif (x <= -4.3e-15)
		tmp = y * ((x / ((y + x) * (y + (x + 1.0)))) / (y + x));
	else
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.4e+142], N[(t$95$0 / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.3e-15], N[(y * N[(N[(x / N[(N[(y + x), $MachinePrecision] * N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(N[(y + x), $MachinePrecision] * N[(N[(y + 1.0), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 6: 85.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{y}{y + x}\\ \mathbf{if}\;x \leq -1.6 \cdot 10^{+154}:\\ \;\;\;\;\frac{t_0}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{elif}\;x \leq -5 \cdot 10^{-19}:\\ \;\;\;\;\frac{x}{x + \left(y + 1\right)} \cdot \frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{t_0}{\left(y + x\right) \cdot \frac{y + 1}{x}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ y (+ y x))))
   (if (<= x -1.6e+154)
     (/ t_0 (+ x (- y (- -1.0 y))))
     (if (<= x -5e-19)
       (* (/ x (+ x (+ y 1.0))) (/ y (* (+ y x) (+ y x))))
       (/ t_0 (* (+ y x) (/ (+ y 1.0) x)))))))

C

double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -1.6e+154) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -5e-19) {
		tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = y / (y + x)
    if (x <= (-1.6d+154)) then
        tmp = t_0 / (x + (y - ((-1.0d0) - y)))
    else if (x <= (-5d-19)) then
        tmp = (x / (x + (y + 1.0d0))) * (y / ((y + x) * (y + x)))
    else
        tmp = t_0 / ((y + x) * ((y + 1.0d0) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = y / (y + x);
	double tmp;
	if (x <= -1.6e+154) {
		tmp = t_0 / (x + (y - (-1.0 - y)));
	} else if (x <= -5e-19) {
		tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
	} else {
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = y / (y + x)
	tmp = 0
	if x <= -1.6e+154:
		tmp = t_0 / (x + (y - (-1.0 - y)))
	elif x <= -5e-19:
		tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)))
	else:
		tmp = t_0 / ((y + x) * ((y + 1.0) / x))
	return tmp

Julia

function code(x, y)
	t_0 = Float64(y / Float64(y + x))
	tmp = 0.0
	if (x <= -1.6e+154)
		tmp = Float64(t_0 / Float64(x + Float64(y - Float64(-1.0 - y))));
	elseif (x <= -5e-19)
		tmp = Float64(Float64(x / Float64(x + Float64(y + 1.0))) * Float64(y / Float64(Float64(y + x) * Float64(y + x))));
	else
		tmp = Float64(t_0 / Float64(Float64(y + x) * Float64(Float64(y + 1.0) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = y / (y + x);
	tmp = 0.0;
	if (x <= -1.6e+154)
		tmp = t_0 / (x + (y - (-1.0 - y)));
	elseif (x <= -5e-19)
		tmp = (x / (x + (y + 1.0))) * (y / ((y + x) * (y + x)));
	else
		tmp = t_0 / ((y + x) * ((y + 1.0) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.6e+154], N[(t$95$0 / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -5e-19], N[(N[(x / N[(x + N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(N[(y + x), $MachinePrecision] * N[(N[(y + 1.0), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 7: 64.7% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\frac{y}{y + x}}{x + \left(y - \left(-1 - y\right)\right)}\\ \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;x \leq -135000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -3.9 \cdot 10^{-113}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ (/ y (+ y x)) (+ x (- y (- -1.0 y))))))
   (if (<= x -1.35e+154)
     t_0
     (if (<= x -135000000.0)
       (/ y (* (+ y x) (+ y x)))
       (if (<= x -3.9e-113) t_0 (/ (/ x (+ y (+ x 1.0))) (+ y x)))))))

C

double code(double x, double y) {
	double t_0 = (y / (y + x)) / (x + (y - (-1.0 - y)));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = t_0;
	} else if (x <= -135000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -3.9e-113) {
		tmp = t_0;
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (y / (y + x)) / (x + (y - ((-1.0d0) - y)))
    if (x <= (-1.35d+154)) then
        tmp = t_0
    else if (x <= (-135000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-3.9d-113)) then
        tmp = t_0
    else
        tmp = (x / (y + (x + 1.0d0))) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = (y / (y + x)) / (x + (y - (-1.0 - y)));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = t_0;
	} else if (x <= -135000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -3.9e-113) {
		tmp = t_0;
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = (y / (y + x)) / (x + (y - (-1.0 - y)))
	tmp = 0
	if x <= -1.35e+154:
		tmp = t_0
	elif x <= -135000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -3.9e-113:
		tmp = t_0
	else:
		tmp = (x / (y + (x + 1.0))) / (y + x)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(Float64(y / Float64(y + x)) / Float64(x + Float64(y - Float64(-1.0 - y))))
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = t_0;
	elseif (x <= -135000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -3.9e-113)
		tmp = t_0;
	else
		tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = (y / (y + x)) / (x + (y - (-1.0 - y)));
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = t_0;
	elseif (x <= -135000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -3.9e-113)
		tmp = t_0;
	else
		tmp = (x / (y + (x + 1.0))) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+154], t$95$0, If[LessEqual[x, -135000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.9e-113], t$95$0, N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 8: 64.7% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \left(y - \left(-1 - y\right)\right)\\ \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{y + x}}{t_0}\\ \mathbf{elif}\;x \leq -420000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{\frac{y}{t_0}}{y + x}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (+ x (- y (- -1.0 y)))))
   (if (<= x -1.35e+154)
     (/ (/ y (+ y x)) t_0)
     (if (<= x -420000000.0)
       (/ y (* (+ y x) (+ y x)))
       (if (<= x -4e-113)
         (/ (/ y t_0) (+ y x))
         (/ (/ x (+ y (+ x 1.0))) (+ y x)))))))

C

double code(double x, double y) {
	double t_0 = x + (y - (-1.0 - y));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / t_0;
	} else if (x <= -420000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / t_0) / (y + x);
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: tmp
    t_0 = x + (y - ((-1.0d0) - y))
    if (x <= (-1.35d+154)) then
        tmp = (y / (y + x)) / t_0
    else if (x <= (-420000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-4d-113)) then
        tmp = (y / t_0) / (y + x)
    else
        tmp = (x / (y + (x + 1.0d0))) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = x + (y - (-1.0 - y));
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / (y + x)) / t_0;
	} else if (x <= -420000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / t_0) / (y + x);
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = x + (y - (-1.0 - y))
	tmp = 0
	if x <= -1.35e+154:
		tmp = (y / (y + x)) / t_0
	elif x <= -420000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -4e-113:
		tmp = (y / t_0) / (y + x)
	else:
		tmp = (x / (y + (x + 1.0))) / (y + x)
	return tmp

Julia

function code(x, y)
	t_0 = Float64(x + Float64(y - Float64(-1.0 - y)))
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = Float64(Float64(y / Float64(y + x)) / t_0);
	elseif (x <= -420000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -4e-113)
		tmp = Float64(Float64(y / t_0) / Float64(y + x));
	else
		tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = x + (y - (-1.0 - y));
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = (y / (y + x)) / t_0;
	elseif (x <= -420000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -4e-113)
		tmp = (y / t_0) / (y + x);
	else
		tmp = (x / (y + (x + 1.0))) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(x + N[(y - N[(-1.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+154], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[x, -420000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4e-113], N[(N[(y / t$95$0), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 9: 64.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{x}}{y + x}\\ \mathbf{elif}\;x \leq -1950000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{y}{y + x} \cdot \frac{1}{x + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -1.35e+154)
   (/ (/ y x) (+ y x))
   (if (<= x -1950000000.0)
     (/ y (* (+ y x) (+ y x)))
     (if (<= x -4e-113)
       (* (/ y (+ y x)) (/ 1.0 (+ x 1.0)))
       (/ (/ x (+ y 1.0)) (+ y x))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -1950000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-1.35d+154)) then
        tmp = (y / x) / (y + x)
    else if (x <= (-1950000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-4d-113)) then
        tmp = (y / (y + x)) * (1.0d0 / (x + 1.0d0))
    else
        tmp = (x / (y + 1.0d0)) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -1950000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -1.35e+154:
		tmp = (y / x) / (y + x)
	elif x <= -1950000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -4e-113:
		tmp = (y / (y + x)) * (1.0 / (x + 1.0))
	else:
		tmp = (x / (y + 1.0)) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = Float64(Float64(y / x) / Float64(y + x));
	elseif (x <= -1950000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(y + x)) * Float64(1.0 / Float64(x + 1.0)));
	else
		tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = (y / x) / (y + x);
	elseif (x <= -1950000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -4e-113)
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	else
		tmp = (x / (y + 1.0)) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -1.35e+154], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1950000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4e-113], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 10: 64.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.2 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{x}}{y + x}\\ \mathbf{elif}\;x \leq -540000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{y}{y + x} \cdot \frac{1}{x + 1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + \left(x + 1\right)}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -2.2e+154)
   (/ (/ y x) (+ y x))
   (if (<= x -540000000.0)
     (/ y (* (+ y x) (+ y x)))
     (if (<= x -4e-113)
       (* (/ y (+ y x)) (/ 1.0 (+ x 1.0)))
       (/ (/ x (+ y (+ x 1.0))) (+ y x))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -2.2e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -540000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-2.2d+154)) then
        tmp = (y / x) / (y + x)
    else if (x <= (-540000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-4d-113)) then
        tmp = (y / (y + x)) * (1.0d0 / (x + 1.0d0))
    else
        tmp = (x / (y + (x + 1.0d0))) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -2.2e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -540000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	} else {
		tmp = (x / (y + (x + 1.0))) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -2.2e+154:
		tmp = (y / x) / (y + x)
	elif x <= -540000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -4e-113:
		tmp = (y / (y + x)) * (1.0 / (x + 1.0))
	else:
		tmp = (x / (y + (x + 1.0))) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -2.2e+154)
		tmp = Float64(Float64(y / x) / Float64(y + x));
	elseif (x <= -540000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(y + x)) * Float64(1.0 / Float64(x + 1.0)));
	else
		tmp = Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -2.2e+154)
		tmp = (y / x) / (y + x);
	elseif (x <= -540000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -4e-113)
		tmp = (y / (y + x)) * (1.0 / (x + 1.0));
	else
		tmp = (x / (y + (x + 1.0))) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -2.2e+154], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -540000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4e-113], N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 11: 82.2% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= y 9.1e-10)
   (/ (* (/ y (+ y x)) (/ x (+ x 1.0))) (+ y x))
   (* (/ y (* (+ y x) (+ y x))) (/ x (+ y 1.0)))))

C

double code(double x, double y) {
	double tmp;
	if (y <= 9.1e-10) {
		tmp = ((y / (y + x)) * (x / (x + 1.0))) / (y + x);
	} else {
		tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (y <= 9.1d-10) then
        tmp = ((y / (y + x)) * (x / (x + 1.0d0))) / (y + x)
    else
        tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (y <= 9.1e-10) {
		tmp = ((y / (y + x)) * (x / (x + 1.0))) / (y + x);
	} else {
		tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if y <= 9.1e-10:
		tmp = ((y / (y + x)) * (x / (x + 1.0))) / (y + x)
	else:
		tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (y <= 9.1e-10)
		tmp = Float64(Float64(Float64(y / Float64(y + x)) * Float64(x / Float64(x + 1.0))) / Float64(y + x));
	else
		tmp = Float64(Float64(y / Float64(Float64(y + x) * Float64(y + x))) * Float64(x / Float64(y + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (y <= 9.1e-10)
		tmp = ((y / (y + x)) * (x / (x + 1.0))) / (y + x);
	else
		tmp = (y / ((y + x) * (y + x))) * (x / (y + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[y, 9.1e-10], N[(N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(x / N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], N[(N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 12: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{y}{y + x} \cdot \frac{\frac{x}{y + \left(x + 1\right)}}{y + x} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (* (/ y (+ y x)) (/ (/ x (+ y (+ x 1.0))) (+ y x))))

C

double code(double x, double y) {
	return (y / (y + x)) * ((x / (y + (x + 1.0))) / (y + x));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (y / (y + x)) * ((x / (y + (x + 1.0d0))) / (y + x))
end function

Java

public static double code(double x, double y) {
	return (y / (y + x)) * ((x / (y + (x + 1.0))) / (y + x));
}

Python

def code(x, y):
	return (y / (y + x)) * ((x / (y + (x + 1.0))) / (y + x))

Julia

function code(x, y)
	return Float64(Float64(y / Float64(y + x)) * Float64(Float64(x / Float64(y + Float64(x + 1.0))) / Float64(y + x)))
end

MATLAB

function tmp = code(x, y)
	tmp = (y / (y + x)) * ((x / (y + (x + 1.0))) / (y + x));
end

Wolfram

code[x_, y_] := N[(N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision] * N[(N[(x / N[(y + N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 13: 64.0% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.35 \cdot 10^{+154}:\\ \;\;\;\;\frac{\frac{y}{x}}{y + x}\\ \mathbf{elif}\;x \leq -48000000:\\ \;\;\;\;\frac{y}{\left(y + x\right) \cdot \left(y + x\right)}\\ \mathbf{elif}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{\frac{y}{x + 1}}{y + x}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -1.35e+154)
   (/ (/ y x) (+ y x))
   (if (<= x -48000000.0)
     (/ y (* (+ y x) (+ y x)))
     (if (<= x -4e-113)
       (/ (/ y (+ x 1.0)) (+ y x))
       (/ (/ x (+ y 1.0)) (+ y x))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -48000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / (y + x);
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-1.35d+154)) then
        tmp = (y / x) / (y + x)
    else if (x <= (-48000000.0d0)) then
        tmp = y / ((y + x) * (y + x))
    else if (x <= (-4d-113)) then
        tmp = (y / (x + 1.0d0)) / (y + x)
    else
        tmp = (x / (y + 1.0d0)) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -1.35e+154) {
		tmp = (y / x) / (y + x);
	} else if (x <= -48000000.0) {
		tmp = y / ((y + x) * (y + x));
	} else if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / (y + x);
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -1.35e+154:
		tmp = (y / x) / (y + x)
	elif x <= -48000000.0:
		tmp = y / ((y + x) * (y + x))
	elif x <= -4e-113:
		tmp = (y / (x + 1.0)) / (y + x)
	else:
		tmp = (x / (y + 1.0)) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -1.35e+154)
		tmp = Float64(Float64(y / x) / Float64(y + x));
	elseif (x <= -48000000.0)
		tmp = Float64(y / Float64(Float64(y + x) * Float64(y + x)));
	elseif (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(x + 1.0)) / Float64(y + x));
	else
		tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -1.35e+154)
		tmp = (y / x) / (y + x);
	elseif (x <= -48000000.0)
		tmp = y / ((y + x) * (y + x));
	elseif (x <= -4e-113)
		tmp = (y / (x + 1.0)) / (y + x);
	else
		tmp = (x / (y + 1.0)) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -1.35e+154], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -48000000.0], N[(y / N[(N[(y + x), $MachinePrecision] * N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4e-113], N[(N[(y / N[(x + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 14: 43.5% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 5.4 \cdot 10^{-198}:\\ \;\;\;\;\frac{y}{x}\\ \mathbf{elif}\;y \leq 0.75:\\ \;\;\;\;\frac{x}{y} - x\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y} \cdot \frac{1}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= y 5.4e-198)
   (/ y x)
   (if (<= y 0.75) (- (/ x y) x) (* (/ x y) (/ 1.0 y)))))

C

double code(double x, double y) {
	double tmp;
	if (y <= 5.4e-198) {
		tmp = y / x;
	} else if (y <= 0.75) {
		tmp = (x / y) - x;
	} else {
		tmp = (x / y) * (1.0 / y);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (y <= 5.4d-198) then
        tmp = y / x
    else if (y <= 0.75d0) then
        tmp = (x / y) - x
    else
        tmp = (x / y) * (1.0d0 / y)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (y <= 5.4e-198) {
		tmp = y / x;
	} else if (y <= 0.75) {
		tmp = (x / y) - x;
	} else {
		tmp = (x / y) * (1.0 / y);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if y <= 5.4e-198:
		tmp = y / x
	elif y <= 0.75:
		tmp = (x / y) - x
	else:
		tmp = (x / y) * (1.0 / y)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (y <= 5.4e-198)
		tmp = Float64(y / x);
	elseif (y <= 0.75)
		tmp = Float64(Float64(x / y) - x);
	else
		tmp = Float64(Float64(x / y) * Float64(1.0 / y));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (y <= 5.4e-198)
		tmp = y / x;
	elseif (y <= 0.75)
		tmp = (x / y) - x;
	else
		tmp = (x / y) * (1.0 / y);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[y, 5.4e-198], N[(y / x), $MachinePrecision], If[LessEqual[y, 0.75], N[(N[(x / y), $MachinePrecision] - x), $MachinePrecision], N[(N[(x / y), $MachinePrecision] * N[(1.0 / y), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 15: 61.3% accurate, 1.5× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -220000000000.0)
   (/ (/ y x) (+ y x))
   (if (<= x -4e-113) (/ y (* x (+ x 1.0))) (/ x (* y (+ y 1.0))))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -220000000000.0) {
		tmp = (y / x) / (y + x);
	} else if (x <= -4e-113) {
		tmp = y / (x * (x + 1.0));
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-220000000000.0d0)) then
        tmp = (y / x) / (y + x)
    else if (x <= (-4d-113)) then
        tmp = y / (x * (x + 1.0d0))
    else
        tmp = x / (y * (y + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -220000000000.0) {
		tmp = (y / x) / (y + x);
	} else if (x <= -4e-113) {
		tmp = y / (x * (x + 1.0));
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -220000000000.0:
		tmp = (y / x) / (y + x)
	elif x <= -4e-113:
		tmp = y / (x * (x + 1.0))
	else:
		tmp = x / (y * (y + 1.0))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -220000000000.0)
		tmp = Float64(Float64(y / x) / Float64(y + x));
	elseif (x <= -4e-113)
		tmp = Float64(y / Float64(x * Float64(x + 1.0)));
	else
		tmp = Float64(x / Float64(y * Float64(y + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -220000000000.0)
		tmp = (y / x) / (y + x);
	elseif (x <= -4e-113)
		tmp = y / (x * (x + 1.0));
	else
		tmp = x / (y * (y + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -220000000000.0], N[(N[(y / x), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4e-113], N[(y / N[(x * N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 16: 61.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{\frac{y}{x + 1}}{x}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -4e-113) (/ (/ y (+ x 1.0)) x) (/ (/ x (+ y 1.0)) (+ y x))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / x;
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-4d-113)) then
        tmp = (y / (x + 1.0d0)) / x
    else
        tmp = (x / (y + 1.0d0)) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / x;
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -4e-113:
		tmp = (y / (x + 1.0)) / x
	else:
		tmp = (x / (y + 1.0)) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(x + 1.0)) / x);
	else
		tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -4e-113)
		tmp = (y / (x + 1.0)) / x;
	else
		tmp = (x / (y + 1.0)) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -4e-113], N[(N[(y / N[(x + 1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 17: 62.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -4 \cdot 10^{-113}:\\ \;\;\;\;\frac{\frac{y}{x + 1}}{y + x}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{y + 1}}{y + x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -4e-113) (/ (/ y (+ x 1.0)) (+ y x)) (/ (/ x (+ y 1.0)) (+ y x))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / (y + x);
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-4d-113)) then
        tmp = (y / (x + 1.0d0)) / (y + x)
    else
        tmp = (x / (y + 1.0d0)) / (y + x)
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / (y + x);
	} else {
		tmp = (x / (y + 1.0)) / (y + x);
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -4e-113:
		tmp = (y / (x + 1.0)) / (y + x)
	else:
		tmp = (x / (y + 1.0)) / (y + x)
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(x + 1.0)) / Float64(y + x));
	else
		tmp = Float64(Float64(x / Float64(y + 1.0)) / Float64(y + x));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -4e-113)
		tmp = (y / (x + 1.0)) / (y + x);
	else
		tmp = (x / (y + 1.0)) / (y + x);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -4e-113], N[(N[(y / N[(x + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(y + 1.0), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 18: 43.4% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= y 9.5e-198) (/ y x) (/ x (* y (+ y 1.0)))))

C

double code(double x, double y) {
	double tmp;
	if (y <= 9.5e-198) {
		tmp = y / x;
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (y <= 9.5d-198) then
        tmp = y / x
    else
        tmp = x / (y * (y + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (y <= 9.5e-198) {
		tmp = y / x;
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if y <= 9.5e-198:
		tmp = y / x
	else:
		tmp = x / (y * (y + 1.0))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (y <= 9.5e-198)
		tmp = Float64(y / x);
	else
		tmp = Float64(x / Float64(y * Float64(y + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (y <= 9.5e-198)
		tmp = y / x;
	else
		tmp = x / (y * (y + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[y, 9.5e-198], N[(y / x), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 19: 60.5% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -4e-113) (/ y (* x (+ x 1.0))) (/ x (* y (+ y 1.0)))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = y / (x * (x + 1.0));
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-4d-113)) then
        tmp = y / (x * (x + 1.0d0))
    else
        tmp = x / (y * (y + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = y / (x * (x + 1.0));
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -4e-113:
		tmp = y / (x * (x + 1.0))
	else:
		tmp = x / (y * (y + 1.0))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -4e-113)
		tmp = Float64(y / Float64(x * Float64(x + 1.0)));
	else
		tmp = Float64(x / Float64(y * Float64(y + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -4e-113)
		tmp = y / (x * (x + 1.0));
	else
		tmp = x / (y * (y + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -4e-113], N[(y / N[(x * N[(x + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 20: 61.2% accurate, 1.9× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (if (<= x -4e-113) (/ (/ y (+ x 1.0)) x) (/ x (* y (+ y 1.0)))))

C

double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / x;
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-4d-113)) then
        tmp = (y / (x + 1.0d0)) / x
    else
        tmp = x / (y * (y + 1.0d0))
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -4e-113) {
		tmp = (y / (x + 1.0)) / x;
	} else {
		tmp = x / (y * (y + 1.0));
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -4e-113:
		tmp = (y / (x + 1.0)) / x
	else:
		tmp = x / (y * (y + 1.0))
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -4e-113)
		tmp = Float64(Float64(y / Float64(x + 1.0)) / x);
	else
		tmp = Float64(x / Float64(y * Float64(y + 1.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -4e-113)
		tmp = (y / (x + 1.0)) / x;
	else
		tmp = x / (y * (y + 1.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -4e-113], N[(N[(y / N[(x + 1.0), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(x / N[(y * N[(y + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 21: 34.5% accurate, 3.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3.9 \cdot 10^{-113}:\\ \;\;\;\;\frac{y}{x}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{y}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (if (<= x -3.9e-113) (/ y x) (/ x y)))

C

double code(double x, double y) {
	double tmp;
	if (x <= -3.9e-113) {
		tmp = y / x;
	} else {
		tmp = x / y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: tmp
    if (x <= (-3.9d-113)) then
        tmp = y / x
    else
        tmp = x / y
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double tmp;
	if (x <= -3.9e-113) {
		tmp = y / x;
	} else {
		tmp = x / y;
	}
	return tmp;
}

Python

def code(x, y):
	tmp = 0
	if x <= -3.9e-113:
		tmp = y / x
	else:
		tmp = x / y
	return tmp

Julia

function code(x, y)
	tmp = 0.0
	if (x <= -3.9e-113)
		tmp = Float64(y / x);
	else
		tmp = Float64(x / y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	tmp = 0.0;
	if (x <= -3.9e-113)
		tmp = y / x;
	else
		tmp = x / y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := If[LessEqual[x, -3.9e-113], N[(y / x), $MachinePrecision], N[(x / y), $MachinePrecision]]

Derivation

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

Alternative 22: 4.2% accurate, 5.7× speedup

Math

\[\begin{array}{l} \\ \frac{0.5}{y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ 0.5 y))

C

double code(double x, double y) {
	return 0.5 / y;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = 0.5d0 / y
end function

Java

public static double code(double x, double y) {
	return 0.5 / y;
}

Python

def code(x, y):
	return 0.5 / y

Julia

function code(x, y)
	return Float64(0.5 / y)
end

MATLAB

function tmp = code(x, y)
	tmp = 0.5 / y;
end

Wolfram

code[x_, y_] := N[(0.5 / y), $MachinePrecision]

Derivation

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

Alternative 23: 4.2% accurate, 5.7× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (/ 1.0 x))

C

double code(double x, double y) {
	return 1.0 / x;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = 1.0d0 / x
end function

Java

public static double code(double x, double y) {
	return 1.0 / x;
}

Python

def code(x, y):
	return 1.0 / x

Julia

function code(x, y)
	return Float64(1.0 / x)
end

MATLAB

function tmp = code(x, y)
	tmp = 1.0 / x;
end

Wolfram

code[x_, y_] := N[(1.0 / x), $MachinePrecision]

Derivation

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

Alternative 24: 26.5% accurate, 5.7× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (/ x y))

C

double code(double x, double y) {
	return x / y;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = x / y
end function

Java

public static double code(double x, double y) {
	return x / y;
}

Python

def code(x, y):
	return x / y

Julia

function code(x, y)
	return Float64(x / y)
end

MATLAB

function tmp = code(x, y)
	tmp = x / y;
end

Wolfram

code[x_, y_] := N[(x / y), $MachinePrecision]

Derivation

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

Developer target: 99.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{\frac{x}{\left(y + 1\right) + x}}{y + x}}{\frac{1}{\frac{y}{y + x}}} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (/ (/ (/ x (+ (+ y 1.0) x)) (+ y x)) (/ 1.0 (/ y (+ y x)))))

C

double code(double x, double y) {
	return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = ((x / ((y + 1.0d0) + x)) / (y + x)) / (1.0d0 / (y / (y + x)))
end function

Java

public static double code(double x, double y) {
	return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}

Python

def code(x, y):
	return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)))

Julia

function code(x, y)
	return Float64(Float64(Float64(x / Float64(Float64(y + 1.0) + x)) / Float64(y + x)) / Float64(1.0 / Float64(y / Float64(y + x))))
end

MATLAB

function tmp = code(x, y)
	tmp = ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
end

Wolfram

code[x_, y_] := N[(N[(N[(x / N[(N[(y + 1.0), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(1.0 / N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2023343 
(FPCore (x y)
  :name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A"
  :precision binary64

  :herbie-target
  (/ (/ (/ x (+ (+ y 1.0) x)) (+ y x)) (/ 1.0 (/ y (+ y x))))

  (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))