Complex division, real part

Percentage Accurate: 62.0% → 80.9%

Time: 11.8s

Alternatives: 13

Speedup: 2.1×

Specification

Math

\[\begin{array}{l} \\ \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))))

C

double code(double a, double b, double c, double d) {
	return ((a * c) + (b * d)) / ((c * c) + (d * d));
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    code = ((a * c) + (b * d)) / ((c * c) + (d * d))
end function

Java

public static double code(double a, double b, double c, double d) {
	return ((a * c) + (b * d)) / ((c * c) + (d * d));
}

Python

def code(a, b, c, d):
	return ((a * c) + (b * d)) / ((c * c) + (d * d))

Julia

function code(a, b, c, d)
	return Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
end

MATLAB

function tmp = code(a, b, c, d)
	tmp = ((a * c) + (b * d)) / ((c * c) + (d * d));
end

Wolfram

code[a_, b_, c_, d_] := N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 62.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))))

C

double code(double a, double b, double c, double d) {
	return ((a * c) + (b * d)) / ((c * c) + (d * d));
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    code = ((a * c) + (b * d)) / ((c * c) + (d * d))
end function

Java

public static double code(double a, double b, double c, double d) {
	return ((a * c) + (b * d)) / ((c * c) + (d * d));
}

Python

def code(a, b, c, d):
	return ((a * c) + (b * d)) / ((c * c) + (d * d))

Julia

function code(a, b, c, d)
	return Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
end

MATLAB

function tmp = code(a, b, c, d)
	tmp = ((a * c) + (b * d)) / ((c * c) + (d * d));
end

Wolfram

code[a_, b_, c_, d_] := N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 80.9% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := {\left(\mathsf{hypot}\left(c, d\right)\right)}^{2}\\ \mathbf{if}\;d \leq -1.65 \cdot 10^{+92}:\\ \;\;\;\;\left(b + \frac{a}{\frac{d}{c}}\right) \cdot \frac{-1}{\mathsf{hypot}\left(c, d\right)}\\ \mathbf{elif}\;d \leq -2.8 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -6 \cdot 10^{+56}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.003:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -6.4 \cdot 10^{-138}:\\ \;\;\;\;\mathsf{fma}\left(a, c, b \cdot d\right) \cdot \frac{1}{t_1}\\ \mathbf{elif}\;d \leq 3.8 \cdot 10^{-144}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 3.3 \cdot 10^{+134}:\\ \;\;\;\;\frac{\mathsf{fma}\left(c, a, b \cdot d\right)}{t_1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, \frac{c}{d}, b\right)}{\mathsf{hypot}\left(c, d\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d))))) (t_1 (pow (hypot c d) 2.0)))
   (if (<= d -1.65e+92)
     (* (+ b (/ a (/ d c))) (/ -1.0 (hypot c d)))
     (if (<= d -2.8e+77)
       t_0
       (if (<= d -6e+56)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.003)
           t_0
           (if (<= d -6.4e-138)
             (* (fma a c (* b d)) (/ 1.0 t_1))
             (if (<= d 3.8e-144)
               t_0
               (if (<= d 3.3e+134)
                 (/ (fma c a (* b d)) t_1)
                 (/ (fma a (/ c d) b) (hypot c d)))))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = pow(hypot(c, d), 2.0);
	double tmp;
	if (d <= -1.65e+92) {
		tmp = (b + (a / (d / c))) * (-1.0 / hypot(c, d));
	} else if (d <= -2.8e+77) {
		tmp = t_0;
	} else if (d <= -6e+56) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.003) {
		tmp = t_0;
	} else if (d <= -6.4e-138) {
		tmp = fma(a, c, (b * d)) * (1.0 / t_1);
	} else if (d <= 3.8e-144) {
		tmp = t_0;
	} else if (d <= 3.3e+134) {
		tmp = fma(c, a, (b * d)) / t_1;
	} else {
		tmp = fma(a, (c / d), b) / hypot(c, d);
	}
	return tmp;
}

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = hypot(c, d) ^ 2.0
	tmp = 0.0
	if (d <= -1.65e+92)
		tmp = Float64(Float64(b + Float64(a / Float64(d / c))) * Float64(-1.0 / hypot(c, d)));
	elseif (d <= -2.8e+77)
		tmp = t_0;
	elseif (d <= -6e+56)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.003)
		tmp = t_0;
	elseif (d <= -6.4e-138)
		tmp = Float64(fma(a, c, Float64(b * d)) * Float64(1.0 / t_1));
	elseif (d <= 3.8e-144)
		tmp = t_0;
	elseif (d <= 3.3e+134)
		tmp = Float64(fma(c, a, Float64(b * d)) / t_1);
	else
		tmp = Float64(fma(a, Float64(c / d), b) / hypot(c, d));
	end
	return tmp
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Power[N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[d, -1.65e+92], N[(N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -2.8e+77], t$95$0, If[LessEqual[d, -6e+56], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.003], t$95$0, If[LessEqual[d, -6.4e-138], N[(N[(a * c + N[(b * d), $MachinePrecision]), $MachinePrecision] * N[(1.0 / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, 3.8e-144], t$95$0, If[LessEqual[d, 3.3e+134], N[(N[(c * a + N[(b * d), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[(a * N[(c / d), $MachinePrecision] + b), $MachinePrecision] / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]]]]]]]]]]

Derivation

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

Alternative 2: 85.4% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \leq 5 \cdot 10^{+267}:\\ \;\;\;\;\frac{1}{\mathsf{hypot}\left(c, d\right)} \cdot \frac{\mathsf{fma}\left(a, c, b \cdot d\right)}{\mathsf{hypot}\left(c, d\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{d} \cdot \left(b + \frac{a}{\frac{d}{c}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (<= (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))) 5e+267)
   (* (/ 1.0 (hypot c d)) (/ (fma a c (* b d)) (hypot c d)))
   (* (/ 1.0 d) (+ b (/ a (/ d c))))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((((a * c) + (b * d)) / ((c * c) + (d * d))) <= 5e+267) {
		tmp = (1.0 / hypot(c, d)) * (fma(a, c, (b * d)) / hypot(c, d));
	} else {
		tmp = (1.0 / d) * (b + (a / (d / c)));
	}
	return tmp;
}

Julia

function code(a, b, c, d)
	tmp = 0.0
	if (Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d))) <= 5e+267)
		tmp = Float64(Float64(1.0 / hypot(c, d)) * Float64(fma(a, c, Float64(b * d)) / hypot(c, d)));
	else
		tmp = Float64(Float64(1.0 / d) * Float64(b + Float64(a / Float64(d / c))));
	end
	return tmp
end

Wolfram

code[a_, b_, c_, d_] := If[LessEqual[N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e+267], N[(N[(1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(a * c + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / d), $MachinePrecision] * N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 3: 81.3% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ \mathbf{if}\;d \leq -3.1 \cdot 10^{+86}:\\ \;\;\;\;\left(b + \frac{a}{\frac{d}{c}}\right) \cdot \frac{-1}{\mathsf{hypot}\left(c, d\right)}\\ \mathbf{elif}\;d \leq -1.25 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.65 \cdot 10^{+55}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.235:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.06 \cdot 10^{-135}:\\ \;\;\;\;\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{elif}\;d \leq 5 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 4.6 \cdot 10^{+133}:\\ \;\;\;\;\frac{\mathsf{fma}\left(c, a, b \cdot d\right)}{{\left(\mathsf{hypot}\left(c, d\right)\right)}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, \frac{c}{d}, b\right)}{\mathsf{hypot}\left(c, d\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d))))))
   (if (<= d -3.1e+86)
     (* (+ b (/ a (/ d c))) (/ -1.0 (hypot c d)))
     (if (<= d -1.25e+77)
       t_0
       (if (<= d -1.65e+55)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.235)
           t_0
           (if (<= d -1.06e-135)
             (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))
             (if (<= d 5e-143)
               t_0
               (if (<= d 4.6e+133)
                 (/ (fma c a (* b d)) (pow (hypot c d) 2.0))
                 (/ (fma a (/ c d) b) (hypot c d)))))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double tmp;
	if (d <= -3.1e+86) {
		tmp = (b + (a / (d / c))) * (-1.0 / hypot(c, d));
	} else if (d <= -1.25e+77) {
		tmp = t_0;
	} else if (d <= -1.65e+55) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.235) {
		tmp = t_0;
	} else if (d <= -1.06e-135) {
		tmp = ((a * c) + (b * d)) / ((c * c) + (d * d));
	} else if (d <= 5e-143) {
		tmp = t_0;
	} else if (d <= 4.6e+133) {
		tmp = fma(c, a, (b * d)) / pow(hypot(c, d), 2.0);
	} else {
		tmp = fma(a, (c / d), b) / hypot(c, d);
	}
	return tmp;
}

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	tmp = 0.0
	if (d <= -3.1e+86)
		tmp = Float64(Float64(b + Float64(a / Float64(d / c))) * Float64(-1.0 / hypot(c, d)));
	elseif (d <= -1.25e+77)
		tmp = t_0;
	elseif (d <= -1.65e+55)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.235)
		tmp = t_0;
	elseif (d <= -1.06e-135)
		tmp = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)));
	elseif (d <= 5e-143)
		tmp = t_0;
	elseif (d <= 4.6e+133)
		tmp = Float64(fma(c, a, Float64(b * d)) / (hypot(c, d) ^ 2.0));
	else
		tmp = Float64(fma(a, Float64(c / d), b) / hypot(c, d));
	end
	return tmp
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -3.1e+86], N[(N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -1.25e+77], t$95$0, If[LessEqual[d, -1.65e+55], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.235], t$95$0, If[LessEqual[d, -1.06e-135], N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, 5e-143], t$95$0, If[LessEqual[d, 4.6e+133], N[(N[(c * a + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[Power[N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(N[(a * N[(c / d), $MachinePrecision] + b), $MachinePrecision] / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

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

Alternative 4: 81.2% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{if}\;d \leq -3.1 \cdot 10^{+86}:\\ \;\;\;\;\left(b + \frac{a}{\frac{d}{c}}\right) \cdot \frac{-1}{\mathsf{hypot}\left(c, d\right)}\\ \mathbf{elif}\;d \leq -4.1 \cdot 10^{+76}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -9 \cdot 10^{+55}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.003:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.04 \cdot 10^{-138}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d \leq 5.5 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 4.4 \cdot 10^{+133}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{\mathsf{fma}\left(a, \frac{c}{d}, b\right)}{\mathsf{hypot}\left(c, d\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))))
   (if (<= d -3.1e+86)
     (* (+ b (/ a (/ d c))) (/ -1.0 (hypot c d)))
     (if (<= d -4.1e+76)
       t_0
       (if (<= d -9e+55)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.003)
           t_0
           (if (<= d -1.04e-138)
             t_1
             (if (<= d 5.5e-143)
               t_0
               (if (<= d 4.4e+133)
                 t_1
                 (/ (fma a (/ c d) b) (hypot c d)))))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -3.1e+86) {
		tmp = (b + (a / (d / c))) * (-1.0 / hypot(c, d));
	} else if (d <= -4.1e+76) {
		tmp = t_0;
	} else if (d <= -9e+55) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.003) {
		tmp = t_0;
	} else if (d <= -1.04e-138) {
		tmp = t_1;
	} else if (d <= 5.5e-143) {
		tmp = t_0;
	} else if (d <= 4.4e+133) {
		tmp = t_1;
	} else {
		tmp = fma(a, (c / d), b) / hypot(c, d);
	}
	return tmp;
}

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	tmp = 0.0
	if (d <= -3.1e+86)
		tmp = Float64(Float64(b + Float64(a / Float64(d / c))) * Float64(-1.0 / hypot(c, d)));
	elseif (d <= -4.1e+76)
		tmp = t_0;
	elseif (d <= -9e+55)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.003)
		tmp = t_0;
	elseif (d <= -1.04e-138)
		tmp = t_1;
	elseif (d <= 5.5e-143)
		tmp = t_0;
	elseif (d <= 4.4e+133)
		tmp = t_1;
	else
		tmp = Float64(fma(a, Float64(c / d), b) / hypot(c, d));
	end
	return tmp
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -3.1e+86], N[(N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -4.1e+76], t$95$0, If[LessEqual[d, -9e+55], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.003], t$95$0, If[LessEqual[d, -1.04e-138], t$95$1, If[LessEqual[d, 5.5e-143], t$95$0, If[LessEqual[d, 4.4e+133], t$95$1, N[(N[(a * N[(c / d), $MachinePrecision] + b), $MachinePrecision] / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]]]]]]]]]]

Derivation

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

Alternative 5: 81.1% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ t_2 := b + \frac{a}{\frac{d}{c}}\\ \mathbf{if}\;d \leq -6.5 \cdot 10^{+85}:\\ \;\;\;\;\frac{1}{d} \cdot t_2\\ \mathbf{elif}\;d \leq -3.5 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.25 \cdot 10^{+56}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.0092:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.06 \cdot 10^{-135}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d \leq 1.95 \cdot 10^{-144}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 1.6 \cdot 10^{+141}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\mathsf{hypot}\left(c, d\right)} \cdot t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))))
        (t_2 (+ b (/ a (/ d c)))))
   (if (<= d -6.5e+85)
     (* (/ 1.0 d) t_2)
     (if (<= d -3.5e+77)
       t_0
       (if (<= d -1.25e+56)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.0092)
           t_0
           (if (<= d -1.06e-135)
             t_1
             (if (<= d 1.95e-144)
               t_0
               (if (<= d 1.6e+141) t_1 (* (/ 1.0 (hypot c d)) t_2))))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double t_2 = b + (a / (d / c));
	double tmp;
	if (d <= -6.5e+85) {
		tmp = (1.0 / d) * t_2;
	} else if (d <= -3.5e+77) {
		tmp = t_0;
	} else if (d <= -1.25e+56) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.0092) {
		tmp = t_0;
	} else if (d <= -1.06e-135) {
		tmp = t_1;
	} else if (d <= 1.95e-144) {
		tmp = t_0;
	} else if (d <= 1.6e+141) {
		tmp = t_1;
	} else {
		tmp = (1.0 / hypot(c, d)) * t_2;
	}
	return tmp;
}

Java

public static double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double t_2 = b + (a / (d / c));
	double tmp;
	if (d <= -6.5e+85) {
		tmp = (1.0 / d) * t_2;
	} else if (d <= -3.5e+77) {
		tmp = t_0;
	} else if (d <= -1.25e+56) {
		tmp = (b / d) + (a / (Math.pow(d, 2.0) / c));
	} else if (d <= -0.0092) {
		tmp = t_0;
	} else if (d <= -1.06e-135) {
		tmp = t_1;
	} else if (d <= 1.95e-144) {
		tmp = t_0;
	} else if (d <= 1.6e+141) {
		tmp = t_1;
	} else {
		tmp = (1.0 / Math.hypot(c, d)) * t_2;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = (1.0 / c) * (a + (b / (c / d)))
	t_1 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	t_2 = b + (a / (d / c))
	tmp = 0
	if d <= -6.5e+85:
		tmp = (1.0 / d) * t_2
	elif d <= -3.5e+77:
		tmp = t_0
	elif d <= -1.25e+56:
		tmp = (b / d) + (a / (math.pow(d, 2.0) / c))
	elif d <= -0.0092:
		tmp = t_0
	elif d <= -1.06e-135:
		tmp = t_1
	elif d <= 1.95e-144:
		tmp = t_0
	elif d <= 1.6e+141:
		tmp = t_1
	else:
		tmp = (1.0 / math.hypot(c, d)) * t_2
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	t_2 = Float64(b + Float64(a / Float64(d / c)))
	tmp = 0.0
	if (d <= -6.5e+85)
		tmp = Float64(Float64(1.0 / d) * t_2);
	elseif (d <= -3.5e+77)
		tmp = t_0;
	elseif (d <= -1.25e+56)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.0092)
		tmp = t_0;
	elseif (d <= -1.06e-135)
		tmp = t_1;
	elseif (d <= 1.95e-144)
		tmp = t_0;
	elseif (d <= 1.6e+141)
		tmp = t_1;
	else
		tmp = Float64(Float64(1.0 / hypot(c, d)) * t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = (1.0 / c) * (a + (b / (c / d)));
	t_1 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	t_2 = b + (a / (d / c));
	tmp = 0.0;
	if (d <= -6.5e+85)
		tmp = (1.0 / d) * t_2;
	elseif (d <= -3.5e+77)
		tmp = t_0;
	elseif (d <= -1.25e+56)
		tmp = (b / d) + (a / ((d ^ 2.0) / c));
	elseif (d <= -0.0092)
		tmp = t_0;
	elseif (d <= -1.06e-135)
		tmp = t_1;
	elseif (d <= 1.95e-144)
		tmp = t_0;
	elseif (d <= 1.6e+141)
		tmp = t_1;
	else
		tmp = (1.0 / hypot(c, d)) * t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -6.5e+85], N[(N[(1.0 / d), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[d, -3.5e+77], t$95$0, If[LessEqual[d, -1.25e+56], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.0092], t$95$0, If[LessEqual[d, -1.06e-135], t$95$1, If[LessEqual[d, 1.95e-144], t$95$0, If[LessEqual[d, 1.6e+141], t$95$1, N[(N[(1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]]]]]]]]]]]

Derivation

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

Alternative 6: 80.9% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := b + \frac{a}{\frac{d}{c}}\\ t_2 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{if}\;d \leq -6.5 \cdot 10^{+91}:\\ \;\;\;\;t_1 \cdot \frac{-1}{\mathsf{hypot}\left(c, d\right)}\\ \mathbf{elif}\;d \leq -2.25 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -4.2 \cdot 10^{+54}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.165:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.66 \cdot 10^{-136}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d \leq 2.7 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 7.8 \cdot 10^{+141}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\mathsf{hypot}\left(c, d\right)} \cdot t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (+ b (/ a (/ d c))))
        (t_2 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))))
   (if (<= d -6.5e+91)
     (* t_1 (/ -1.0 (hypot c d)))
     (if (<= d -2.25e+77)
       t_0
       (if (<= d -4.2e+54)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.165)
           t_0
           (if (<= d -1.66e-136)
             t_2
             (if (<= d 2.7e-143)
               t_0
               (if (<= d 7.8e+141) t_2 (* (/ 1.0 (hypot c d)) t_1))))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = b + (a / (d / c));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -6.5e+91) {
		tmp = t_1 * (-1.0 / hypot(c, d));
	} else if (d <= -2.25e+77) {
		tmp = t_0;
	} else if (d <= -4.2e+54) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.165) {
		tmp = t_0;
	} else if (d <= -1.66e-136) {
		tmp = t_2;
	} else if (d <= 2.7e-143) {
		tmp = t_0;
	} else if (d <= 7.8e+141) {
		tmp = t_2;
	} else {
		tmp = (1.0 / hypot(c, d)) * t_1;
	}
	return tmp;
}

Java

public static double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = b + (a / (d / c));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -6.5e+91) {
		tmp = t_1 * (-1.0 / Math.hypot(c, d));
	} else if (d <= -2.25e+77) {
		tmp = t_0;
	} else if (d <= -4.2e+54) {
		tmp = (b / d) + (a / (Math.pow(d, 2.0) / c));
	} else if (d <= -0.165) {
		tmp = t_0;
	} else if (d <= -1.66e-136) {
		tmp = t_2;
	} else if (d <= 2.7e-143) {
		tmp = t_0;
	} else if (d <= 7.8e+141) {
		tmp = t_2;
	} else {
		tmp = (1.0 / Math.hypot(c, d)) * t_1;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = (1.0 / c) * (a + (b / (c / d)))
	t_1 = b + (a / (d / c))
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	tmp = 0
	if d <= -6.5e+91:
		tmp = t_1 * (-1.0 / math.hypot(c, d))
	elif d <= -2.25e+77:
		tmp = t_0
	elif d <= -4.2e+54:
		tmp = (b / d) + (a / (math.pow(d, 2.0) / c))
	elif d <= -0.165:
		tmp = t_0
	elif d <= -1.66e-136:
		tmp = t_2
	elif d <= 2.7e-143:
		tmp = t_0
	elif d <= 7.8e+141:
		tmp = t_2
	else:
		tmp = (1.0 / math.hypot(c, d)) * t_1
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(b + Float64(a / Float64(d / c)))
	t_2 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	tmp = 0.0
	if (d <= -6.5e+91)
		tmp = Float64(t_1 * Float64(-1.0 / hypot(c, d)));
	elseif (d <= -2.25e+77)
		tmp = t_0;
	elseif (d <= -4.2e+54)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.165)
		tmp = t_0;
	elseif (d <= -1.66e-136)
		tmp = t_2;
	elseif (d <= 2.7e-143)
		tmp = t_0;
	elseif (d <= 7.8e+141)
		tmp = t_2;
	else
		tmp = Float64(Float64(1.0 / hypot(c, d)) * t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = (1.0 / c) * (a + (b / (c / d)));
	t_1 = b + (a / (d / c));
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	tmp = 0.0;
	if (d <= -6.5e+91)
		tmp = t_1 * (-1.0 / hypot(c, d));
	elseif (d <= -2.25e+77)
		tmp = t_0;
	elseif (d <= -4.2e+54)
		tmp = (b / d) + (a / ((d ^ 2.0) / c));
	elseif (d <= -0.165)
		tmp = t_0;
	elseif (d <= -1.66e-136)
		tmp = t_2;
	elseif (d <= 2.7e-143)
		tmp = t_0;
	elseif (d <= 7.8e+141)
		tmp = t_2;
	else
		tmp = (1.0 / hypot(c, d)) * t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -6.5e+91], N[(t$95$1 * N[(-1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -2.25e+77], t$95$0, If[LessEqual[d, -4.2e+54], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.165], t$95$0, If[LessEqual[d, -1.66e-136], t$95$2, If[LessEqual[d, 2.7e-143], t$95$0, If[LessEqual[d, 7.8e+141], t$95$2, N[(N[(1.0 / N[Sqrt[c ^ 2 + d ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]]]]]]]]]]]

Derivation

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

Alternative 7: 81.1% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := \frac{1}{d} \cdot \left(b + \frac{a}{\frac{d}{c}}\right)\\ t_2 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{if}\;d \leq -6.4 \cdot 10^{+85}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d \leq -3.5 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.1 \cdot 10^{+55}:\\ \;\;\;\;\frac{b}{d} + c \cdot \frac{a}{{d}^{2}}\\ \mathbf{elif}\;d \leq -0.23:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -1.08 \cdot 10^{-135}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d \leq 4 \cdot 10^{-144}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 2.05 \cdot 10^{+141}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (* (/ 1.0 d) (+ b (/ a (/ d c)))))
        (t_2 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))))
   (if (<= d -6.4e+85)
     t_1
     (if (<= d -3.5e+77)
       t_0
       (if (<= d -1.1e+55)
         (+ (/ b d) (* c (/ a (pow d 2.0))))
         (if (<= d -0.23)
           t_0
           (if (<= d -1.08e-135)
             t_2
             (if (<= d 4e-144) t_0 (if (<= d 2.05e+141) t_2 t_1)))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -6.4e+85) {
		tmp = t_1;
	} else if (d <= -3.5e+77) {
		tmp = t_0;
	} else if (d <= -1.1e+55) {
		tmp = (b / d) + (c * (a / pow(d, 2.0)));
	} else if (d <= -0.23) {
		tmp = t_0;
	} else if (d <= -1.08e-135) {
		tmp = t_2;
	} else if (d <= 4e-144) {
		tmp = t_0;
	} else if (d <= 2.05e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (1.0d0 / c) * (a + (b / (c / d)))
    t_1 = (1.0d0 / d) * (b + (a / (d / c)))
    t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
    if (d <= (-6.4d+85)) then
        tmp = t_1
    else if (d <= (-3.5d+77)) then
        tmp = t_0
    else if (d <= (-1.1d+55)) then
        tmp = (b / d) + (c * (a / (d ** 2.0d0)))
    else if (d <= (-0.23d0)) then
        tmp = t_0
    else if (d <= (-1.08d-135)) then
        tmp = t_2
    else if (d <= 4d-144) then
        tmp = t_0
    else if (d <= 2.05d+141) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -6.4e+85) {
		tmp = t_1;
	} else if (d <= -3.5e+77) {
		tmp = t_0;
	} else if (d <= -1.1e+55) {
		tmp = (b / d) + (c * (a / Math.pow(d, 2.0)));
	} else if (d <= -0.23) {
		tmp = t_0;
	} else if (d <= -1.08e-135) {
		tmp = t_2;
	} else if (d <= 4e-144) {
		tmp = t_0;
	} else if (d <= 2.05e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = (1.0 / c) * (a + (b / (c / d)))
	t_1 = (1.0 / d) * (b + (a / (d / c)))
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	tmp = 0
	if d <= -6.4e+85:
		tmp = t_1
	elif d <= -3.5e+77:
		tmp = t_0
	elif d <= -1.1e+55:
		tmp = (b / d) + (c * (a / math.pow(d, 2.0)))
	elif d <= -0.23:
		tmp = t_0
	elif d <= -1.08e-135:
		tmp = t_2
	elif d <= 4e-144:
		tmp = t_0
	elif d <= 2.05e+141:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(Float64(1.0 / d) * Float64(b + Float64(a / Float64(d / c))))
	t_2 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	tmp = 0.0
	if (d <= -6.4e+85)
		tmp = t_1;
	elseif (d <= -3.5e+77)
		tmp = t_0;
	elseif (d <= -1.1e+55)
		tmp = Float64(Float64(b / d) + Float64(c * Float64(a / (d ^ 2.0))));
	elseif (d <= -0.23)
		tmp = t_0;
	elseif (d <= -1.08e-135)
		tmp = t_2;
	elseif (d <= 4e-144)
		tmp = t_0;
	elseif (d <= 2.05e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = (1.0 / c) * (a + (b / (c / d)));
	t_1 = (1.0 / d) * (b + (a / (d / c)));
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	tmp = 0.0;
	if (d <= -6.4e+85)
		tmp = t_1;
	elseif (d <= -3.5e+77)
		tmp = t_0;
	elseif (d <= -1.1e+55)
		tmp = (b / d) + (c * (a / (d ^ 2.0)));
	elseif (d <= -0.23)
		tmp = t_0;
	elseif (d <= -1.08e-135)
		tmp = t_2;
	elseif (d <= 4e-144)
		tmp = t_0;
	elseif (d <= 2.05e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 / d), $MachinePrecision] * N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -6.4e+85], t$95$1, If[LessEqual[d, -3.5e+77], t$95$0, If[LessEqual[d, -1.1e+55], N[(N[(b / d), $MachinePrecision] + N[(c * N[(a / N[Power[d, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.23], t$95$0, If[LessEqual[d, -1.08e-135], t$95$2, If[LessEqual[d, 4e-144], t$95$0, If[LessEqual[d, 2.05e+141], t$95$2, t$95$1]]]]]]]]]]

Derivation

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

Alternative 8: 80.9% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := \frac{1}{d} \cdot \left(b + \frac{a}{\frac{d}{c}}\right)\\ t_2 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{if}\;d \leq -5.4 \cdot 10^{+85}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d \leq -2.7 \cdot 10^{+77}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -8.5 \cdot 10^{+56}:\\ \;\;\;\;\frac{b}{d} + \frac{a}{\frac{{d}^{2}}{c}}\\ \mathbf{elif}\;d \leq -0.285:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -9 \cdot 10^{-138}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d \leq 6.3 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 1.7 \cdot 10^{+141}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (* (/ 1.0 d) (+ b (/ a (/ d c)))))
        (t_2 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))))
   (if (<= d -5.4e+85)
     t_1
     (if (<= d -2.7e+77)
       t_0
       (if (<= d -8.5e+56)
         (+ (/ b d) (/ a (/ (pow d 2.0) c)))
         (if (<= d -0.285)
           t_0
           (if (<= d -9e-138)
             t_2
             (if (<= d 6.3e-143) t_0 (if (<= d 1.7e+141) t_2 t_1)))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -5.4e+85) {
		tmp = t_1;
	} else if (d <= -2.7e+77) {
		tmp = t_0;
	} else if (d <= -8.5e+56) {
		tmp = (b / d) + (a / (pow(d, 2.0) / c));
	} else if (d <= -0.285) {
		tmp = t_0;
	} else if (d <= -9e-138) {
		tmp = t_2;
	} else if (d <= 6.3e-143) {
		tmp = t_0;
	} else if (d <= 1.7e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (1.0d0 / c) * (a + (b / (c / d)))
    t_1 = (1.0d0 / d) * (b + (a / (d / c)))
    t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
    if (d <= (-5.4d+85)) then
        tmp = t_1
    else if (d <= (-2.7d+77)) then
        tmp = t_0
    else if (d <= (-8.5d+56)) then
        tmp = (b / d) + (a / ((d ** 2.0d0) / c))
    else if (d <= (-0.285d0)) then
        tmp = t_0
    else if (d <= (-9d-138)) then
        tmp = t_2
    else if (d <= 6.3d-143) then
        tmp = t_0
    else if (d <= 1.7d+141) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -5.4e+85) {
		tmp = t_1;
	} else if (d <= -2.7e+77) {
		tmp = t_0;
	} else if (d <= -8.5e+56) {
		tmp = (b / d) + (a / (Math.pow(d, 2.0) / c));
	} else if (d <= -0.285) {
		tmp = t_0;
	} else if (d <= -9e-138) {
		tmp = t_2;
	} else if (d <= 6.3e-143) {
		tmp = t_0;
	} else if (d <= 1.7e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = (1.0 / c) * (a + (b / (c / d)))
	t_1 = (1.0 / d) * (b + (a / (d / c)))
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	tmp = 0
	if d <= -5.4e+85:
		tmp = t_1
	elif d <= -2.7e+77:
		tmp = t_0
	elif d <= -8.5e+56:
		tmp = (b / d) + (a / (math.pow(d, 2.0) / c))
	elif d <= -0.285:
		tmp = t_0
	elif d <= -9e-138:
		tmp = t_2
	elif d <= 6.3e-143:
		tmp = t_0
	elif d <= 1.7e+141:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(Float64(1.0 / d) * Float64(b + Float64(a / Float64(d / c))))
	t_2 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	tmp = 0.0
	if (d <= -5.4e+85)
		tmp = t_1;
	elseif (d <= -2.7e+77)
		tmp = t_0;
	elseif (d <= -8.5e+56)
		tmp = Float64(Float64(b / d) + Float64(a / Float64((d ^ 2.0) / c)));
	elseif (d <= -0.285)
		tmp = t_0;
	elseif (d <= -9e-138)
		tmp = t_2;
	elseif (d <= 6.3e-143)
		tmp = t_0;
	elseif (d <= 1.7e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = (1.0 / c) * (a + (b / (c / d)));
	t_1 = (1.0 / d) * (b + (a / (d / c)));
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	tmp = 0.0;
	if (d <= -5.4e+85)
		tmp = t_1;
	elseif (d <= -2.7e+77)
		tmp = t_0;
	elseif (d <= -8.5e+56)
		tmp = (b / d) + (a / ((d ^ 2.0) / c));
	elseif (d <= -0.285)
		tmp = t_0;
	elseif (d <= -9e-138)
		tmp = t_2;
	elseif (d <= 6.3e-143)
		tmp = t_0;
	elseif (d <= 1.7e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 / d), $MachinePrecision] * N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -5.4e+85], t$95$1, If[LessEqual[d, -2.7e+77], t$95$0, If[LessEqual[d, -8.5e+56], N[(N[(b / d), $MachinePrecision] + N[(a / N[(N[Power[d, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[d, -0.285], t$95$0, If[LessEqual[d, -9e-138], t$95$2, If[LessEqual[d, 6.3e-143], t$95$0, If[LessEqual[d, 1.7e+141], t$95$2, t$95$1]]]]]]]]]]

Derivation

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

Alternative 9: 81.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ t_1 := \frac{1}{d} \cdot \left(b + \frac{a}{\frac{d}{c}}\right)\\ t_2 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{if}\;d \leq -5.8 \cdot 10^{+85}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d \leq -4.7 \cdot 10^{+76}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -6.5 \cdot 10^{+53}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d \leq -0.19:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq -4.8 \cdot 10^{-139}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d \leq 5 \cdot 10^{-143}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d \leq 1.6 \cdot 10^{+141}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (* (/ 1.0 c) (+ a (/ b (/ c d)))))
        (t_1 (* (/ 1.0 d) (+ b (/ a (/ d c)))))
        (t_2 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d)))))
   (if (<= d -5.8e+85)
     t_1
     (if (<= d -4.7e+76)
       t_0
       (if (<= d -6.5e+53)
         t_2
         (if (<= d -0.19)
           t_0
           (if (<= d -4.8e-139)
             t_2
             (if (<= d 5e-143) t_0 (if (<= d 1.6e+141) t_2 t_1)))))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -5.8e+85) {
		tmp = t_1;
	} else if (d <= -4.7e+76) {
		tmp = t_0;
	} else if (d <= -6.5e+53) {
		tmp = t_2;
	} else if (d <= -0.19) {
		tmp = t_0;
	} else if (d <= -4.8e-139) {
		tmp = t_2;
	} else if (d <= 5e-143) {
		tmp = t_0;
	} else if (d <= 1.6e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = (1.0d0 / c) * (a + (b / (c / d)))
    t_1 = (1.0d0 / d) * (b + (a / (d / c)))
    t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
    if (d <= (-5.8d+85)) then
        tmp = t_1
    else if (d <= (-4.7d+76)) then
        tmp = t_0
    else if (d <= (-6.5d+53)) then
        tmp = t_2
    else if (d <= (-0.19d0)) then
        tmp = t_0
    else if (d <= (-4.8d-139)) then
        tmp = t_2
    else if (d <= 5d-143) then
        tmp = t_0
    else if (d <= 1.6d+141) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double t_0 = (1.0 / c) * (a + (b / (c / d)));
	double t_1 = (1.0 / d) * (b + (a / (d / c)));
	double t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double tmp;
	if (d <= -5.8e+85) {
		tmp = t_1;
	} else if (d <= -4.7e+76) {
		tmp = t_0;
	} else if (d <= -6.5e+53) {
		tmp = t_2;
	} else if (d <= -0.19) {
		tmp = t_0;
	} else if (d <= -4.8e-139) {
		tmp = t_2;
	} else if (d <= 5e-143) {
		tmp = t_0;
	} else if (d <= 1.6e+141) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = (1.0 / c) * (a + (b / (c / d)))
	t_1 = (1.0 / d) * (b + (a / (d / c)))
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	tmp = 0
	if d <= -5.8e+85:
		tmp = t_1
	elif d <= -4.7e+76:
		tmp = t_0
	elif d <= -6.5e+53:
		tmp = t_2
	elif d <= -0.19:
		tmp = t_0
	elif d <= -4.8e-139:
		tmp = t_2
	elif d <= 5e-143:
		tmp = t_0
	elif d <= 1.6e+141:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))))
	t_1 = Float64(Float64(1.0 / d) * Float64(b + Float64(a / Float64(d / c))))
	t_2 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	tmp = 0.0
	if (d <= -5.8e+85)
		tmp = t_1;
	elseif (d <= -4.7e+76)
		tmp = t_0;
	elseif (d <= -6.5e+53)
		tmp = t_2;
	elseif (d <= -0.19)
		tmp = t_0;
	elseif (d <= -4.8e-139)
		tmp = t_2;
	elseif (d <= 5e-143)
		tmp = t_0;
	elseif (d <= 1.6e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = (1.0 / c) * (a + (b / (c / d)));
	t_1 = (1.0 / d) * (b + (a / (d / c)));
	t_2 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	tmp = 0.0;
	if (d <= -5.8e+85)
		tmp = t_1;
	elseif (d <= -4.7e+76)
		tmp = t_0;
	elseif (d <= -6.5e+53)
		tmp = t_2;
	elseif (d <= -0.19)
		tmp = t_0;
	elseif (d <= -4.8e-139)
		tmp = t_2;
	elseif (d <= 5e-143)
		tmp = t_0;
	elseif (d <= 1.6e+141)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(1.0 / d), $MachinePrecision] * N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(a * c), $MachinePrecision] + N[(b * d), $MachinePrecision]), $MachinePrecision] / N[(N[(c * c), $MachinePrecision] + N[(d * d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d, -5.8e+85], t$95$1, If[LessEqual[d, -4.7e+76], t$95$0, If[LessEqual[d, -6.5e+53], t$95$2, If[LessEqual[d, -0.19], t$95$0, If[LessEqual[d, -4.8e-139], t$95$2, If[LessEqual[d, 5e-143], t$95$0, If[LessEqual[d, 1.6e+141], t$95$2, t$95$1]]]]]]]]]]

Derivation

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

Alternative 10: 77.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -3.1 \cdot 10^{+86} \lor \neg \left(d \leq -2.8 \cdot 10^{+76} \lor \neg \left(d \leq -4.6 \cdot 10^{+54}\right) \land d \leq 5.8 \cdot 10^{+34}\right):\\ \;\;\;\;\frac{1}{d} \cdot \left(b + \frac{a}{\frac{d}{c}}\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -3.1e+86)
         (not (or (<= d -2.8e+76) (and (not (<= d -4.6e+54)) (<= d 5.8e+34)))))
   (* (/ 1.0 d) (+ b (/ a (/ d c))))
   (* (/ 1.0 c) (+ a (/ b (/ c d))))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -3.1e+86) || !((d <= -2.8e+76) || (!(d <= -4.6e+54) && (d <= 5.8e+34)))) {
		tmp = (1.0 / d) * (b + (a / (d / c)));
	} else {
		tmp = (1.0 / c) * (a + (b / (c / d)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: tmp
    if ((d <= (-3.1d+86)) .or. (.not. (d <= (-2.8d+76)) .or. (.not. (d <= (-4.6d+54))) .and. (d <= 5.8d+34))) then
        tmp = (1.0d0 / d) * (b + (a / (d / c)))
    else
        tmp = (1.0d0 / c) * (a + (b / (c / d)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -3.1e+86) || !((d <= -2.8e+76) || (!(d <= -4.6e+54) && (d <= 5.8e+34)))) {
		tmp = (1.0 / d) * (b + (a / (d / c)));
	} else {
		tmp = (1.0 / c) * (a + (b / (c / d)));
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -3.1e+86) or not ((d <= -2.8e+76) or (not (d <= -4.6e+54) and (d <= 5.8e+34))):
		tmp = (1.0 / d) * (b + (a / (d / c)))
	else:
		tmp = (1.0 / c) * (a + (b / (c / d)))
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -3.1e+86) || !((d <= -2.8e+76) || (!(d <= -4.6e+54) && (d <= 5.8e+34))))
		tmp = Float64(Float64(1.0 / d) * Float64(b + Float64(a / Float64(d / c))));
	else
		tmp = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if ((d <= -3.1e+86) || ~(((d <= -2.8e+76) || (~((d <= -4.6e+54)) && (d <= 5.8e+34)))))
		tmp = (1.0 / d) * (b + (a / (d / c)));
	else
		tmp = (1.0 / c) * (a + (b / (c / d)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -3.1e+86], N[Not[Or[LessEqual[d, -2.8e+76], And[N[Not[LessEqual[d, -4.6e+54]], $MachinePrecision], LessEqual[d, 5.8e+34]]]], $MachinePrecision]], N[(N[(1.0 / d), $MachinePrecision] * N[(b + N[(a / N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 11: 71.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -3.6 \cdot 10^{+121} \lor \neg \left(d \leq 1.1 \cdot 10^{+34}\right):\\ \;\;\;\;\frac{b}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{c} \cdot \left(a + \frac{b}{\frac{c}{d}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -3.6e+121) (not (<= d 1.1e+34)))
   (/ b d)
   (* (/ 1.0 c) (+ a (/ b (/ c d))))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -3.6e+121) || !(d <= 1.1e+34)) {
		tmp = b / d;
	} else {
		tmp = (1.0 / c) * (a + (b / (c / d)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: tmp
    if ((d <= (-3.6d+121)) .or. (.not. (d <= 1.1d+34))) then
        tmp = b / d
    else
        tmp = (1.0d0 / c) * (a + (b / (c / d)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -3.6e+121) || !(d <= 1.1e+34)) {
		tmp = b / d;
	} else {
		tmp = (1.0 / c) * (a + (b / (c / d)));
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -3.6e+121) or not (d <= 1.1e+34):
		tmp = b / d
	else:
		tmp = (1.0 / c) * (a + (b / (c / d)))
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -3.6e+121) || !(d <= 1.1e+34))
		tmp = Float64(b / d);
	else
		tmp = Float64(Float64(1.0 / c) * Float64(a + Float64(b / Float64(c / d))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if ((d <= -3.6e+121) || ~((d <= 1.1e+34)))
		tmp = b / d;
	else
		tmp = (1.0 / c) * (a + (b / (c / d)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -3.6e+121], N[Not[LessEqual[d, 1.1e+34]], $MachinePrecision]], N[(b / d), $MachinePrecision], N[(N[(1.0 / c), $MachinePrecision] * N[(a + N[(b / N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 12: 62.6% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -2.5 \cdot 10^{+121} \lor \neg \left(d \leq 9.5 \cdot 10^{-14}\right):\\ \;\;\;\;\frac{b}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{c}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -2.5e+121) (not (<= d 9.5e-14))) (/ b d) (/ a c)))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -2.5e+121) || !(d <= 9.5e-14)) {
		tmp = b / d;
	} else {
		tmp = a / c;
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: tmp
    if ((d <= (-2.5d+121)) .or. (.not. (d <= 9.5d-14))) then
        tmp = b / d
    else
        tmp = a / c
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -2.5e+121) || !(d <= 9.5e-14)) {
		tmp = b / d;
	} else {
		tmp = a / c;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -2.5e+121) or not (d <= 9.5e-14):
		tmp = b / d
	else:
		tmp = a / c
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -2.5e+121) || !(d <= 9.5e-14))
		tmp = Float64(b / d);
	else
		tmp = Float64(a / c);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if ((d <= -2.5e+121) || ~((d <= 9.5e-14)))
		tmp = b / d;
	else
		tmp = a / c;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -2.5e+121], N[Not[LessEqual[d, 9.5e-14]], $MachinePrecision]], N[(b / d), $MachinePrecision], N[(a / c), $MachinePrecision]]

Derivation

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

Alternative 13: 43.0% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ \frac{a}{c} \end{array} \]

FPCore

(FPCore (a b c d) :precision binary64 (/ a c))

C

double code(double a, double b, double c, double d) {
	return a / c;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    code = a / c
end function

Java

public static double code(double a, double b, double c, double d) {
	return a / c;
}

Python

def code(a, b, c, d):
	return a / c

Julia

function code(a, b, c, d)
	return Float64(a / c)
end

MATLAB

function tmp = code(a, b, c, d)
	tmp = a / c;
end

Wolfram

code[a_, b_, c_, d_] := N[(a / c), $MachinePrecision]

Derivation

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

Developer target: 99.3% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\left|d\right| < \left|c\right|:\\ \;\;\;\;\frac{a + b \cdot \frac{d}{c}}{c + d \cdot \frac{d}{c}}\\ \mathbf{else}:\\ \;\;\;\;\frac{b + a \cdot \frac{c}{d}}{d + c \cdot \frac{c}{d}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (< (fabs d) (fabs c))
   (/ (+ a (* b (/ d c))) (+ c (* d (/ d c))))
   (/ (+ b (* a (/ c d))) (+ d (* c (/ c d))))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if (fabs(d) < fabs(c)) {
		tmp = (a + (b * (d / c))) / (c + (d * (d / c)));
	} else {
		tmp = (b + (a * (c / d))) / (d + (c * (c / d)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c, d)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8), intent (in) :: d
    real(8) :: tmp
    if (abs(d) < abs(c)) then
        tmp = (a + (b * (d / c))) / (c + (d * (d / c)))
    else
        tmp = (b + (a * (c / d))) / (d + (c * (c / d)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if (Math.abs(d) < Math.abs(c)) {
		tmp = (a + (b * (d / c))) / (c + (d * (d / c)));
	} else {
		tmp = (b + (a * (c / d))) / (d + (c * (c / d)));
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if math.fabs(d) < math.fabs(c):
		tmp = (a + (b * (d / c))) / (c + (d * (d / c)))
	else:
		tmp = (b + (a * (c / d))) / (d + (c * (c / d)))
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if (abs(d) < abs(c))
		tmp = Float64(Float64(a + Float64(b * Float64(d / c))) / Float64(c + Float64(d * Float64(d / c))));
	else
		tmp = Float64(Float64(b + Float64(a * Float64(c / d))) / Float64(d + Float64(c * Float64(c / d))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if (abs(d) < abs(c))
		tmp = (a + (b * (d / c))) / (c + (d * (d / c)));
	else
		tmp = (b + (a * (c / d))) / (d + (c * (c / d)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Less[N[Abs[d], $MachinePrecision], N[Abs[c], $MachinePrecision]], N[(N[(a + N[(b * N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(c + N[(d * N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + N[(a * N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(d + N[(c * N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Reproduce

herbie shell --seed 2023347 
(FPCore (a b c d)
  :name "Complex division, real part"
  :precision binary64

  :herbie-target
  (if (< (fabs d) (fabs c)) (/ (+ a (* b (/ d c))) (+ c (* d (/ d c)))) (/ (+ b (* a (/ c d))) (+ d (* c (/ c d)))))

  (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))))