Complex division, real part

Percentage Accurate: 63.6% → 83.7%

Time: 9.6s

Alternatives: 8

Speedup: 1.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: 63.6% 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: 83.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ t_1 := \frac{b + a \cdot \frac{c}{d}}{d}\\ \mathbf{if}\;d \leq -1.02 \cdot 10^{+89}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;d \leq -6.5 \cdot 10^{-152}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d \leq 2.8 \cdot 10^{-70}:\\ \;\;\;\;\frac{a + \frac{b \cdot d}{c}}{c}\\ \mathbf{elif}\;d \leq 5.8 \cdot 10^{+120}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (let* ((t_0 (/ (+ (* a c) (* b d)) (+ (* c c) (* d d))))
        (t_1 (/ (+ b (* a (/ c d))) d)))
   (if (<= d -1.02e+89)
     t_1
     (if (<= d -6.5e-152)
       t_0
       (if (<= d 2.8e-70)
         (/ (+ a (/ (* b d) c)) c)
         (if (<= d 5.8e+120) t_0 t_1))))))

C

double code(double a, double b, double c, double d) {
	double t_0 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double t_1 = (b + (a * (c / d))) / d;
	double tmp;
	if (d <= -1.02e+89) {
		tmp = t_1;
	} else if (d <= -6.5e-152) {
		tmp = t_0;
	} else if (d <= 2.8e-70) {
		tmp = (a + ((b * d) / c)) / c;
	} else if (d <= 5.8e+120) {
		tmp = t_0;
	} 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) :: tmp
    t_0 = ((a * c) + (b * d)) / ((c * c) + (d * d))
    t_1 = (b + (a * (c / d))) / d
    if (d <= (-1.02d+89)) then
        tmp = t_1
    else if (d <= (-6.5d-152)) then
        tmp = t_0
    else if (d <= 2.8d-70) then
        tmp = (a + ((b * d) / c)) / c
    else if (d <= 5.8d+120) then
        tmp = t_0
    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 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	double t_1 = (b + (a * (c / d))) / d;
	double tmp;
	if (d <= -1.02e+89) {
		tmp = t_1;
	} else if (d <= -6.5e-152) {
		tmp = t_0;
	} else if (d <= 2.8e-70) {
		tmp = (a + ((b * d) / c)) / c;
	} else if (d <= 5.8e+120) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	t_0 = ((a * c) + (b * d)) / ((c * c) + (d * d))
	t_1 = (b + (a * (c / d))) / d
	tmp = 0
	if d <= -1.02e+89:
		tmp = t_1
	elif d <= -6.5e-152:
		tmp = t_0
	elif d <= 2.8e-70:
		tmp = (a + ((b * d) / c)) / c
	elif d <= 5.8e+120:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(a, b, c, d)
	t_0 = Float64(Float64(Float64(a * c) + Float64(b * d)) / Float64(Float64(c * c) + Float64(d * d)))
	t_1 = Float64(Float64(b + Float64(a * Float64(c / d))) / d)
	tmp = 0.0
	if (d <= -1.02e+89)
		tmp = t_1;
	elseif (d <= -6.5e-152)
		tmp = t_0;
	elseif (d <= 2.8e-70)
		tmp = Float64(Float64(a + Float64(Float64(b * d) / c)) / c);
	elseif (d <= 5.8e+120)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	t_0 = ((a * c) + (b * d)) / ((c * c) + (d * d));
	t_1 = (b + (a * (c / d))) / d;
	tmp = 0.0;
	if (d <= -1.02e+89)
		tmp = t_1;
	elseif (d <= -6.5e-152)
		tmp = t_0;
	elseif (d <= 2.8e-70)
		tmp = (a + ((b * d) / c)) / c;
	elseif (d <= 5.8e+120)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := Block[{t$95$0 = 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$1 = N[(N[(b + N[(a * N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision]}, If[LessEqual[d, -1.02e+89], t$95$1, If[LessEqual[d, -6.5e-152], t$95$0, If[LessEqual[d, 2.8e-70], N[(N[(a + N[(N[(b * d), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision], If[LessEqual[d, 5.8e+120], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if d < -1.0199999999999999e89 or 5.8000000000000003e120 < d

   1. Initial program 28.0%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in d around inf 79.7%

      \[\leadsto \color{blue}{\frac{b + \frac{a \cdot c}{d}}{d}} \]
   4. Step-by-step derivation

      1. associate-/l* 90.6%

         \[\leadsto \frac{b + \color{blue}{a \cdot \frac{c}{d}}}{d} \]

   5. Simplified 90.6%

      \[\leadsto \color{blue}{\frac{b + a \cdot \frac{c}{d}}{d}} \]

   if -1.0199999999999999e89 < d < -6.5000000000000001e-152 or 2.7999999999999999e-70 < d < 5.8000000000000003e120

   1. Initial program 85.3%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   if -6.5000000000000001e-152 < d < 2.7999999999999999e-70

   1. Initial program 71.6%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 90.7%

      \[\leadsto \color{blue}{\frac{a + \frac{b \cdot d}{c}}{c}} \]
   4. Step-by-step derivation

      1. *-commutative 90.7%

         \[\leadsto \frac{a + \frac{\color{blue}{d \cdot b}}{c}}{c} \]

   5. Simplified 90.7%

      \[\leadsto \color{blue}{\frac{a + \frac{d \cdot b}{c}}{c}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 88.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d \leq -1.02 \cdot 10^{+89}:\\ \;\;\;\;\frac{b + a \cdot \frac{c}{d}}{d}\\ \mathbf{elif}\;d \leq -6.5 \cdot 10^{-152}:\\ \;\;\;\;\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{elif}\;d \leq 2.8 \cdot 10^{-70}:\\ \;\;\;\;\frac{a + \frac{b \cdot d}{c}}{c}\\ \mathbf{elif}\;d \leq 5.8 \cdot 10^{+120}:\\ \;\;\;\;\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d}\\ \mathbf{else}:\\ \;\;\;\;\frac{b + a \cdot \frac{c}{d}}{d}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 85.3% 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^{+268}:\\ \;\;\;\;\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{b + a \cdot \frac{c}{d}}{d}\\ \end{array} \end{array} \]

FPCore

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

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((((a * c) + (b * d)) / ((c * c) + (d * d))) <= 5e+268) {
		tmp = (1.0 / hypot(c, d)) * (fma(a, c, (b * d)) / hypot(c, d));
	} else {
		tmp = (b + (a * (c / d))) / d;
	}
	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+268)
		tmp = Float64(Float64(1.0 / hypot(c, d)) * Float64(fma(a, c, Float64(b * d)) / hypot(c, d)));
	else
		tmp = Float64(Float64(b + Float64(a * Float64(c / d))) / d);
	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+268], 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[(b + N[(a * N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (+.f64 (*.f64 a c) (*.f64 b d)) (+.f64 (*.f64 c c) (*.f64 d d))) < 5.0000000000000002e268

   1. Initial program 79.9%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing
   3. Step-by-step derivation

      1. *-un-lft-identity 79.9%

         \[\leadsto \frac{\color{blue}{1 \cdot \left(a \cdot c + b \cdot d\right)}}{c \cdot c + d \cdot d} \]

      2. add-sqr-sqrt 79.9%

         \[\leadsto \frac{1 \cdot \left(a \cdot c + b \cdot d\right)}{\color{blue}{\sqrt{c \cdot c + d \cdot d} \cdot \sqrt{c \cdot c + d \cdot d}}} \]

      3. times-frac 79.8%

         \[\leadsto \color{blue}{\frac{1}{\sqrt{c \cdot c + d \cdot d}} \cdot \frac{a \cdot c + b \cdot d}{\sqrt{c \cdot c + d \cdot d}}} \]

      4. hypot-define 79.8%

         \[\leadsto \frac{1}{\color{blue}{\mathsf{hypot}\left(c, d\right)}} \cdot \frac{a \cdot c + b \cdot d}{\sqrt{c \cdot c + d \cdot d}} \]

      5. fma-define 79.8%

         \[\leadsto \frac{1}{\mathsf{hypot}\left(c, d\right)} \cdot \frac{\color{blue}{\mathsf{fma}\left(a, c, b \cdot d\right)}}{\sqrt{c \cdot c + d \cdot d}} \]

      6. hypot-define 95.0%

         \[\leadsto \frac{1}{\mathsf{hypot}\left(c, d\right)} \cdot \frac{\mathsf{fma}\left(a, c, b \cdot d\right)}{\color{blue}{\mathsf{hypot}\left(c, d\right)}} \]

   4. Applied egg-rr 95.0%

      \[\leadsto \color{blue}{\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)}} \]

   if 5.0000000000000002e268 < (/.f64 (+.f64 (*.f64 a c) (*.f64 b d)) (+.f64 (*.f64 c c) (*.f64 d d)))

   1. Initial program 20.3%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in d around inf 58.0%

      \[\leadsto \color{blue}{\frac{b + \frac{a \cdot c}{d}}{d}} \]
   4. Step-by-step derivation

      1. associate-/l* 69.8%

         \[\leadsto \frac{b + \color{blue}{a \cdot \frac{c}{d}}}{d} \]

   5. Simplified 69.8%

      \[\leadsto \color{blue}{\frac{b + a \cdot \frac{c}{d}}{d}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 63.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -1.06 \cdot 10^{-11}:\\ \;\;\;\;\frac{b}{d}\\ \mathbf{elif}\;d \leq 8 \cdot 10^{+49}:\\ \;\;\;\;\frac{a}{c}\\ \mathbf{elif}\;d \leq 4.7 \cdot 10^{+88}:\\ \;\;\;\;\frac{a \cdot \frac{c}{d}}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{b}{d}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (<= d -1.06e-11)
   (/ b d)
   (if (<= d 8e+49) (/ a c) (if (<= d 4.7e+88) (/ (* a (/ c d)) d) (/ b d)))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if (d <= -1.06e-11) {
		tmp = b / d;
	} else if (d <= 8e+49) {
		tmp = a / c;
	} else if (d <= 4.7e+88) {
		tmp = (a * (c / d)) / d;
	} else {
		tmp = b / 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 <= (-1.06d-11)) then
        tmp = b / d
    else if (d <= 8d+49) then
        tmp = a / c
    else if (d <= 4.7d+88) then
        tmp = (a * (c / d)) / d
    else
        tmp = b / d
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if (d <= -1.06e-11) {
		tmp = b / d;
	} else if (d <= 8e+49) {
		tmp = a / c;
	} else if (d <= 4.7e+88) {
		tmp = (a * (c / d)) / d;
	} else {
		tmp = b / d;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if d <= -1.06e-11:
		tmp = b / d
	elif d <= 8e+49:
		tmp = a / c
	elif d <= 4.7e+88:
		tmp = (a * (c / d)) / d
	else:
		tmp = b / d
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if (d <= -1.06e-11)
		tmp = Float64(b / d);
	elseif (d <= 8e+49)
		tmp = Float64(a / c);
	elseif (d <= 4.7e+88)
		tmp = Float64(Float64(a * Float64(c / d)) / d);
	else
		tmp = Float64(b / d);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if (d <= -1.06e-11)
		tmp = b / d;
	elseif (d <= 8e+49)
		tmp = a / c;
	elseif (d <= 4.7e+88)
		tmp = (a * (c / d)) / d;
	else
		tmp = b / d;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[LessEqual[d, -1.06e-11], N[(b / d), $MachinePrecision], If[LessEqual[d, 8e+49], N[(a / c), $MachinePrecision], If[LessEqual[d, 4.7e+88], N[(N[(a * N[(c / d), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision], N[(b / d), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if d < -1.05999999999999993e-11 or 4.70000000000000007e88 < d

   1. Initial program 39.0%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around 0 71.3%

      \[\leadsto \color{blue}{\frac{b}{d}} \]

   if -1.05999999999999993e-11 < d < 7.99999999999999957e49

   1. Initial program 77.8%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 63.2%

      \[\leadsto \color{blue}{\frac{a}{c}} \]

   if 7.99999999999999957e49 < d < 4.70000000000000007e88

   1. Initial program 91.0%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in d around inf 76.1%

      \[\leadsto \color{blue}{\frac{b + \frac{a \cdot c}{d}}{d}} \]

   4. Taylor expanded in b around 0 59.7%

      \[\leadsto \frac{\color{blue}{\frac{a \cdot c}{d}}}{d} \]
   5. Step-by-step derivation

      1. associate-*r/ 60.0%

         \[\leadsto \frac{\color{blue}{a \cdot \frac{c}{d}}}{d} \]

   6. Simplified 60.0%

      \[\leadsto \frac{\color{blue}{a \cdot \frac{c}{d}}}{d} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 63.6% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -0.0032:\\ \;\;\;\;\frac{b}{d}\\ \mathbf{elif}\;d \leq 2.8 \cdot 10^{+47}:\\ \;\;\;\;\frac{a}{c}\\ \mathbf{elif}\;d \leq 4.5 \cdot 10^{+90}:\\ \;\;\;\;\frac{c}{d} \cdot \frac{a}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{b}{d}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (<= d -0.0032)
   (/ b d)
   (if (<= d 2.8e+47)
     (/ a c)
     (if (<= d 4.5e+90) (* (/ c d) (/ a d)) (/ b d)))))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if (d <= -0.0032) {
		tmp = b / d;
	} else if (d <= 2.8e+47) {
		tmp = a / c;
	} else if (d <= 4.5e+90) {
		tmp = (c / d) * (a / d);
	} else {
		tmp = b / 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 <= (-0.0032d0)) then
        tmp = b / d
    else if (d <= 2.8d+47) then
        tmp = a / c
    else if (d <= 4.5d+90) then
        tmp = (c / d) * (a / d)
    else
        tmp = b / d
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if (d <= -0.0032) {
		tmp = b / d;
	} else if (d <= 2.8e+47) {
		tmp = a / c;
	} else if (d <= 4.5e+90) {
		tmp = (c / d) * (a / d);
	} else {
		tmp = b / d;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if d <= -0.0032:
		tmp = b / d
	elif d <= 2.8e+47:
		tmp = a / c
	elif d <= 4.5e+90:
		tmp = (c / d) * (a / d)
	else:
		tmp = b / d
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if (d <= -0.0032)
		tmp = Float64(b / d);
	elseif (d <= 2.8e+47)
		tmp = Float64(a / c);
	elseif (d <= 4.5e+90)
		tmp = Float64(Float64(c / d) * Float64(a / d));
	else
		tmp = Float64(b / d);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if (d <= -0.0032)
		tmp = b / d;
	elseif (d <= 2.8e+47)
		tmp = a / c;
	elseif (d <= 4.5e+90)
		tmp = (c / d) * (a / d);
	else
		tmp = b / d;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[LessEqual[d, -0.0032], N[(b / d), $MachinePrecision], If[LessEqual[d, 2.8e+47], N[(a / c), $MachinePrecision], If[LessEqual[d, 4.5e+90], N[(N[(c / d), $MachinePrecision] * N[(a / d), $MachinePrecision]), $MachinePrecision], N[(b / d), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if d < -0.00320000000000000015 or 4.5e90 < d

   1. Initial program 39.0%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around 0 71.3%

      \[\leadsto \color{blue}{\frac{b}{d}} \]

   if -0.00320000000000000015 < d < 2.79999999999999988e47

   1. Initial program 77.8%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 63.2%

      \[\leadsto \color{blue}{\frac{a}{c}} \]

   if 2.79999999999999988e47 < d < 4.5e90

   1. Initial program 91.0%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in d around inf 76.1%

      \[\leadsto \color{blue}{\frac{b + \frac{a \cdot c}{d}}{d}} \]

   4. Taylor expanded in b around 0 59.7%

      \[\leadsto \frac{\color{blue}{\frac{a \cdot c}{d}}}{d} \]
   5. Step-by-step derivation

      1. associate-/l/ 59.9%

         \[\leadsto \color{blue}{\frac{a \cdot c}{d \cdot d}} \]

      2. *-commutative 59.9%

         \[\leadsto \frac{\color{blue}{c \cdot a}}{d \cdot d} \]

      3. times-frac 59.9%

         \[\leadsto \color{blue}{\frac{c}{d} \cdot \frac{a}{d}} \]

   6. Applied egg-rr 59.9%

      \[\leadsto \color{blue}{\frac{c}{d} \cdot \frac{a}{d}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 78.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d \leq -2.75 \cdot 10^{-41} \lor \neg \left(d \leq 6.2 \cdot 10^{-12}\right):\\ \;\;\;\;\frac{b + a \cdot \frac{c}{d}}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{a + \frac{b \cdot d}{c}}{c}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -2.75e-41) (not (<= d 6.2e-12)))
   (/ (+ b (* a (/ c d))) d)
   (/ (+ a (/ (* b d) c)) c)))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -2.75e-41) || !(d <= 6.2e-12)) {
		tmp = (b + (a * (c / d))) / d;
	} else {
		tmp = (a + ((b * d) / c)) / 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.75d-41)) .or. (.not. (d <= 6.2d-12))) then
        tmp = (b + (a * (c / d))) / d
    else
        tmp = (a + ((b * d) / c)) / 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.75e-41) || !(d <= 6.2e-12)) {
		tmp = (b + (a * (c / d))) / d;
	} else {
		tmp = (a + ((b * d) / c)) / c;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -2.75e-41) or not (d <= 6.2e-12):
		tmp = (b + (a * (c / d))) / d
	else:
		tmp = (a + ((b * d) / c)) / c
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -2.75e-41) || !(d <= 6.2e-12))
		tmp = Float64(Float64(b + Float64(a * Float64(c / d))) / d);
	else
		tmp = Float64(Float64(a + Float64(Float64(b * d) / c)) / c);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if ((d <= -2.75e-41) || ~((d <= 6.2e-12)))
		tmp = (b + (a * (c / d))) / d;
	else
		tmp = (a + ((b * d) / c)) / c;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -2.75e-41], N[Not[LessEqual[d, 6.2e-12]], $MachinePrecision]], N[(N[(b + N[(a * N[(c / d), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / d), $MachinePrecision], N[(N[(a + N[(N[(b * d), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d < -2.75000000000000011e-41 or 6.2000000000000002e-12 < d

   1. Initial program 50.8%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in d around inf 72.4%

      \[\leadsto \color{blue}{\frac{b + \frac{a \cdot c}{d}}{d}} \]
   4. Step-by-step derivation

      1. associate-/l* 78.6%

         \[\leadsto \frac{b + \color{blue}{a \cdot \frac{c}{d}}}{d} \]

   5. Simplified 78.6%

      \[\leadsto \color{blue}{\frac{b + a \cdot \frac{c}{d}}{d}} \]

   if -2.75000000000000011e-41 < d < 6.2000000000000002e-12

   1. Initial program 77.6%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 84.8%

      \[\leadsto \color{blue}{\frac{a + \frac{b \cdot d}{c}}{c}} \]
   4. Step-by-step derivation

      1. *-commutative 84.8%

         \[\leadsto \frac{a + \frac{\color{blue}{d \cdot b}}{c}}{c} \]

   5. Simplified 84.8%

      \[\leadsto \color{blue}{\frac{a + \frac{d \cdot b}{c}}{c}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 81.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d \leq -2.75 \cdot 10^{-41} \lor \neg \left(d \leq 6.2 \cdot 10^{-12}\right):\\ \;\;\;\;\frac{b + a \cdot \frac{c}{d}}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{a + \frac{b \cdot d}{c}}{c}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 72.8% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -8e-10) (not (<= d 4.9e+120)))
   (/ b d)
   (/ (+ a (* b (/ d c))) c)))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -8e-10) || !(d <= 4.9e+120)) {
		tmp = b / d;
	} else {
		tmp = (a + (b * (d / c))) / 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 <= (-8d-10)) .or. (.not. (d <= 4.9d+120))) then
        tmp = b / d
    else
        tmp = (a + (b * (d / c))) / c
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -8e-10) || !(d <= 4.9e+120)) {
		tmp = b / d;
	} else {
		tmp = (a + (b * (d / c))) / c;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -8e-10) or not (d <= 4.9e+120):
		tmp = b / d
	else:
		tmp = (a + (b * (d / c))) / c
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -8e-10) || !(d <= 4.9e+120))
		tmp = Float64(b / d);
	else
		tmp = Float64(Float64(a + Float64(b * Float64(d / c))) / c);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c, d)
	tmp = 0.0;
	if ((d <= -8e-10) || ~((d <= 4.9e+120)))
		tmp = b / d;
	else
		tmp = (a + (b * (d / c))) / c;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -8e-10], N[Not[LessEqual[d, 4.9e+120]], $MachinePrecision]], N[(b / d), $MachinePrecision], N[(N[(a + N[(b * N[(d / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d < -8.00000000000000029e-10 or 4.9000000000000001e120 < d

   1. Initial program 38.4%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around 0 71.9%

      \[\leadsto \color{blue}{\frac{b}{d}} \]

   if -8.00000000000000029e-10 < d < 4.9000000000000001e120

   1. Initial program 78.9%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 74.1%

      \[\leadsto \color{blue}{\frac{a + \frac{b \cdot d}{c}}{c}} \]
   4. Step-by-step derivation

      1. *-commutative 74.1%

         \[\leadsto \frac{a + \frac{\color{blue}{d \cdot b}}{c}}{c} \]

   5. Simplified 74.1%

      \[\leadsto \color{blue}{\frac{a + \frac{d \cdot b}{c}}{c}} \]

   6. Taylor expanded in d around 0 74.1%

      \[\leadsto \frac{a + \color{blue}{\frac{b \cdot d}{c}}}{c} \]
   7. Step-by-step derivation

      1. associate-*r/ 74.8%

         \[\leadsto \frac{a + \color{blue}{b \cdot \frac{d}{c}}}{c} \]

   8. Simplified 74.8%

      \[\leadsto \frac{a + \color{blue}{b \cdot \frac{d}{c}}}{c} \]
3. Recombined 2 regimes into one program.

4. Final simplification 73.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d \leq -8 \cdot 10^{-10} \lor \neg \left(d \leq 4.9 \cdot 10^{+120}\right):\\ \;\;\;\;\frac{b}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{a + b \cdot \frac{d}{c}}{c}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 64.6% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (a b c d)
 :precision binary64
 (if (or (<= d -13.5) (not (<= d 2.4e+39))) (/ b d) (/ a c)))

C

double code(double a, double b, double c, double d) {
	double tmp;
	if ((d <= -13.5) || !(d <= 2.4e+39)) {
		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 <= (-13.5d0)) .or. (.not. (d <= 2.4d+39))) 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 <= -13.5) || !(d <= 2.4e+39)) {
		tmp = b / d;
	} else {
		tmp = a / c;
	}
	return tmp;
}

Python

def code(a, b, c, d):
	tmp = 0
	if (d <= -13.5) or not (d <= 2.4e+39):
		tmp = b / d
	else:
		tmp = a / c
	return tmp

Julia

function code(a, b, c, d)
	tmp = 0.0
	if ((d <= -13.5) || !(d <= 2.4e+39))
		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 <= -13.5) || ~((d <= 2.4e+39)))
		tmp = b / d;
	else
		tmp = a / c;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_, d_] := If[Or[LessEqual[d, -13.5], N[Not[LessEqual[d, 2.4e+39]], $MachinePrecision]], N[(b / d), $MachinePrecision], N[(a / c), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d < -13.5 or 2.4000000000000001e39 < d

   1. Initial program 46.1%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around 0 64.6%

      \[\leadsto \color{blue}{\frac{b}{d}} \]

   if -13.5 < d < 2.4000000000000001e39

   1. Initial program 77.8%

      \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
   2. Add Preprocessing

   3. Taylor expanded in c around inf 64.1%

      \[\leadsto \color{blue}{\frac{a}{c}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 64.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d \leq -13.5 \lor \neg \left(d \leq 2.4 \cdot 10^{+39}\right):\\ \;\;\;\;\frac{b}{d}\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{c}\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 43.6% 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

1. Initial program 64.3%

   \[\frac{a \cdot c + b \cdot d}{c \cdot c + d \cdot d} \]
2. Add Preprocessing

3. Taylor expanded in c around inf 43.3%

   \[\leadsto \color{blue}{\frac{a}{c}} \]
4. Add Preprocessing

Developer Target 1: 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 2024137 
(FPCore (a b c d)
  :name "Complex division, real part"
  :precision binary64

  :alt
  (! :herbie-platform default (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))))