The quadratic formula (r2)

Percentage Accurate: 52.1% → 85.7%

Time: 15.1s

Alternatives: 10

Speedup: 11.6×

Specification

Math

\[\begin{array}{l} \\ \frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/ (- (- b) (sqrt (- (* b b) (* 4.0 (* a c))))) (* 2.0 a)))

C

double code(double a, double b, double c) {
	return (-b - sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = (-b - sqrt(((b * b) - (4.0d0 * (a * c))))) / (2.0d0 * a)
end function

Java

public static double code(double a, double b, double c) {
	return (-b - Math.sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
}

Python

def code(a, b, c):
	return (-b - math.sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a)

Julia

function code(a, b, c)
	return Float64(Float64(Float64(-b) - sqrt(Float64(Float64(b * b) - Float64(4.0 * Float64(a * c))))) / Float64(2.0 * a))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-b - sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
end

Wolfram

code[a_, b_, c_] := N[(N[((-b) - N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(4.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]

Initial Program: 52.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/ (- (- b) (sqrt (- (* b b) (* 4.0 (* a c))))) (* 2.0 a)))

C

double code(double a, double b, double c) {
	return (-b - sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = (-b - sqrt(((b * b) - (4.0d0 * (a * c))))) / (2.0d0 * a)
end function

Java

public static double code(double a, double b, double c) {
	return (-b - Math.sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
}

Python

def code(a, b, c):
	return (-b - math.sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a)

Julia

function code(a, b, c)
	return Float64(Float64(Float64(-b) - sqrt(Float64(Float64(b * b) - Float64(4.0 * Float64(a * c))))) / Float64(2.0 * a))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-b - sqrt(((b * b) - (4.0 * (a * c))))) / (2.0 * a);
end

Wolfram

code[a_, b_, c_] := N[(N[((-b) - N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(4.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]

Alternative 1: 85.7% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2.6 \cdot 10^{-79}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 3.35 \cdot 10^{+137}:\\ \;\;\;\;-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(c \cdot -4\right)}}{a} + \frac{b}{a}\right)\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -2.6e-79)
   (- 0.0 (/ c b))
   (if (<= b 3.35e+137)
     (* -0.5 (+ (/ (sqrt (+ (* b b) (* a (* c -4.0)))) a) (/ b a)))
     (- 0.0 (/ b a)))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -2.6e-79) {
		tmp = 0.0 - (c / b);
	} else if (b <= 3.35e+137) {
		tmp = -0.5 * ((sqrt(((b * b) + (a * (c * -4.0)))) / a) + (b / a));
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-2.6d-79)) then
        tmp = 0.0d0 - (c / b)
    else if (b <= 3.35d+137) then
        tmp = (-0.5d0) * ((sqrt(((b * b) + (a * (c * (-4.0d0))))) / a) + (b / a))
    else
        tmp = 0.0d0 - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -2.6e-79) {
		tmp = 0.0 - (c / b);
	} else if (b <= 3.35e+137) {
		tmp = -0.5 * ((Math.sqrt(((b * b) + (a * (c * -4.0)))) / a) + (b / a));
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -2.6e-79:
		tmp = 0.0 - (c / b)
	elif b <= 3.35e+137:
		tmp = -0.5 * ((math.sqrt(((b * b) + (a * (c * -4.0)))) / a) + (b / a))
	else:
		tmp = 0.0 - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -2.6e-79)
		tmp = Float64(0.0 - Float64(c / b));
	elseif (b <= 3.35e+137)
		tmp = Float64(-0.5 * Float64(Float64(sqrt(Float64(Float64(b * b) + Float64(a * Float64(c * -4.0)))) / a) + Float64(b / a)));
	else
		tmp = Float64(0.0 - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -2.6e-79)
		tmp = 0.0 - (c / b);
	elseif (b <= 3.35e+137)
		tmp = -0.5 * ((sqrt(((b * b) + (a * (c * -4.0)))) / a) + (b / a));
	else
		tmp = 0.0 - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -2.6e-79], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.35e+137], N[(-0.5 * N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / a), $MachinePrecision] + N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -2.59999999999999994e-79

   1. Initial program 13.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 86.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 86.3%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -2.59999999999999994e-79 < b < 3.3499999999999999e137

   1. Initial program 84.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 84.5%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   6. Applied egg-rr 84.8%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\frac{b}{a}, -0.5, \frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{\frac{a}{-0.5}}\right)} \]
   7. Step-by-step derivation

      1. +-commutative N/A

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

      2. associate-/r/ N/A

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

      3. distribute-rgt-out N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \color{blue}{\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a} + \frac{b}{a}\right)}\right) \]

      5. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a}\right), \color{blue}{\left(\frac{b}{a}\right)}\right)\right) \]

   8. Applied egg-rr 84.8%

      \[\leadsto \color{blue}{-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(-4 \cdot c\right)}}{a} + \frac{b}{a}\right)} \]

   if 3.3499999999999999e137 < b

   1. Initial program 48.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{b}{a}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      4. /-lowering-/.f64 98.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 98.3%

      \[\leadsto \color{blue}{0 - \frac{b}{a}} \]
   6. Step-by-step derivation

      1. sub0-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-lowering-neg.f64 N/A

         \[\leadsto \mathsf{neg.f64}\left(\left(\frac{b}{a}\right)\right) \]

   7. Applied egg-rr 98.3%

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

4. Final simplification 88.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2.6 \cdot 10^{-79}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 3.35 \cdot 10^{+137}:\\ \;\;\;\;-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(c \cdot -4\right)}}{a} + \frac{b}{a}\right)\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 85.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-78}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 10^{+137}:\\ \;\;\;\;\frac{\left(0 - b\right) - \sqrt{b \cdot b - 4 \cdot \left(c \cdot a\right)}}{a \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -2e-78)
   (- 0.0 (/ c b))
   (if (<= b 1e+137)
     (/ (- (- 0.0 b) (sqrt (- (* b b) (* 4.0 (* c a))))) (* a 2.0))
     (- 0.0 (/ b a)))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-78) {
		tmp = 0.0 - (c / b);
	} else if (b <= 1e+137) {
		tmp = ((0.0 - b) - sqrt(((b * b) - (4.0 * (c * a))))) / (a * 2.0);
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-2d-78)) then
        tmp = 0.0d0 - (c / b)
    else if (b <= 1d+137) then
        tmp = ((0.0d0 - b) - sqrt(((b * b) - (4.0d0 * (c * a))))) / (a * 2.0d0)
    else
        tmp = 0.0d0 - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-78) {
		tmp = 0.0 - (c / b);
	} else if (b <= 1e+137) {
		tmp = ((0.0 - b) - Math.sqrt(((b * b) - (4.0 * (c * a))))) / (a * 2.0);
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -2e-78:
		tmp = 0.0 - (c / b)
	elif b <= 1e+137:
		tmp = ((0.0 - b) - math.sqrt(((b * b) - (4.0 * (c * a))))) / (a * 2.0)
	else:
		tmp = 0.0 - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -2e-78)
		tmp = Float64(0.0 - Float64(c / b));
	elseif (b <= 1e+137)
		tmp = Float64(Float64(Float64(0.0 - b) - sqrt(Float64(Float64(b * b) - Float64(4.0 * Float64(c * a))))) / Float64(a * 2.0));
	else
		tmp = Float64(0.0 - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -2e-78)
		tmp = 0.0 - (c / b);
	elseif (b <= 1e+137)
		tmp = ((0.0 - b) - sqrt(((b * b) - (4.0 * (c * a))))) / (a * 2.0);
	else
		tmp = 0.0 - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -2e-78], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+137], N[(N[(N[(0.0 - b), $MachinePrecision] - N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -2e-78

   1. Initial program 13.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 86.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 86.3%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -2e-78 < b < 1e137

   1. Initial program 84.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   if 1e137 < b

   1. Initial program 48.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{b}{a}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      4. /-lowering-/.f64 98.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 98.3%

      \[\leadsto \color{blue}{0 - \frac{b}{a}} \]
   6. Step-by-step derivation

      1. sub0-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-lowering-neg.f64 N/A

         \[\leadsto \mathsf{neg.f64}\left(\left(\frac{b}{a}\right)\right) \]

   7. Applied egg-rr 98.3%

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

4. Final simplification 88.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-78}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 10^{+137}:\\ \;\;\;\;\frac{\left(0 - b\right) - \sqrt{b \cdot b - 4 \cdot \left(c \cdot a\right)}}{a \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 85.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -4 \cdot 10^{-82}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+137}:\\ \;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -4e-82)
   (- 0.0 (/ c b))
   (if (<= b 4.8e+137)
     (* (/ -0.5 a) (+ b (sqrt (+ (* b b) (* c (* a -4.0))))))
     (- 0.0 (/ b a)))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -4e-82) {
		tmp = 0.0 - (c / b);
	} else if (b <= 4.8e+137) {
		tmp = (-0.5 / a) * (b + sqrt(((b * b) + (c * (a * -4.0)))));
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-4d-82)) then
        tmp = 0.0d0 - (c / b)
    else if (b <= 4.8d+137) then
        tmp = ((-0.5d0) / a) * (b + sqrt(((b * b) + (c * (a * (-4.0d0))))))
    else
        tmp = 0.0d0 - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -4e-82) {
		tmp = 0.0 - (c / b);
	} else if (b <= 4.8e+137) {
		tmp = (-0.5 / a) * (b + Math.sqrt(((b * b) + (c * (a * -4.0)))));
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -4e-82:
		tmp = 0.0 - (c / b)
	elif b <= 4.8e+137:
		tmp = (-0.5 / a) * (b + math.sqrt(((b * b) + (c * (a * -4.0)))))
	else:
		tmp = 0.0 - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -4e-82)
		tmp = Float64(0.0 - Float64(c / b));
	elseif (b <= 4.8e+137)
		tmp = Float64(Float64(-0.5 / a) * Float64(b + sqrt(Float64(Float64(b * b) + Float64(c * Float64(a * -4.0))))));
	else
		tmp = Float64(0.0 - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -4e-82)
		tmp = 0.0 - (c / b);
	elseif (b <= 4.8e+137)
		tmp = (-0.5 / a) * (b + sqrt(((b * b) + (c * (a * -4.0)))));
	else
		tmp = 0.0 - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -4e-82], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.8e+137], N[(N[(-0.5 / a), $MachinePrecision] * N[(b + N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -4e-82

   1. Initial program 13.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 86.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 86.3%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -4e-82 < b < 4.79999999999999966e137

   1. Initial program 84.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 84.5%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   if 4.79999999999999966e137 < b

   1. Initial program 48.8%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{b}{a}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      4. /-lowering-/.f64 98.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 98.3%

      \[\leadsto \color{blue}{0 - \frac{b}{a}} \]
   6. Step-by-step derivation

      1. sub0-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-lowering-neg.f64 N/A

         \[\leadsto \mathsf{neg.f64}\left(\left(\frac{b}{a}\right)\right) \]

   7. Applied egg-rr 98.3%

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

4. Final simplification 88.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -4 \cdot 10^{-82}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 4.8 \cdot 10^{+137}:\\ \;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 80.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -9 \cdot 10^{-82}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 1.7 \cdot 10^{-102}:\\ \;\;\;\;\frac{\left(0 - b\right) - \sqrt{c \cdot \left(a \cdot -4\right)}}{a \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -9e-82)
   (- 0.0 (/ c b))
   (if (<= b 1.7e-102)
     (/ (- (- 0.0 b) (sqrt (* c (* a -4.0)))) (* a 2.0))
     (* -0.5 (+ (/ b a) (+ (/ b a) (/ (* c -2.0) b)))))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -9e-82) {
		tmp = 0.0 - (c / b);
	} else if (b <= 1.7e-102) {
		tmp = ((0.0 - b) - sqrt((c * (a * -4.0)))) / (a * 2.0);
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-9d-82)) then
        tmp = 0.0d0 - (c / b)
    else if (b <= 1.7d-102) then
        tmp = ((0.0d0 - b) - sqrt((c * (a * (-4.0d0))))) / (a * 2.0d0)
    else
        tmp = (-0.5d0) * ((b / a) + ((b / a) + ((c * (-2.0d0)) / b)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -9e-82) {
		tmp = 0.0 - (c / b);
	} else if (b <= 1.7e-102) {
		tmp = ((0.0 - b) - Math.sqrt((c * (a * -4.0)))) / (a * 2.0);
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -9e-82:
		tmp = 0.0 - (c / b)
	elif b <= 1.7e-102:
		tmp = ((0.0 - b) - math.sqrt((c * (a * -4.0)))) / (a * 2.0)
	else:
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)))
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -9e-82)
		tmp = Float64(0.0 - Float64(c / b));
	elseif (b <= 1.7e-102)
		tmp = Float64(Float64(Float64(0.0 - b) - sqrt(Float64(c * Float64(a * -4.0)))) / Float64(a * 2.0));
	else
		tmp = Float64(-0.5 * Float64(Float64(b / a) + Float64(Float64(b / a) + Float64(Float64(c * -2.0) / b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -9e-82)
		tmp = 0.0 - (c / b);
	elseif (b <= 1.7e-102)
		tmp = ((0.0 - b) - sqrt((c * (a * -4.0)))) / (a * 2.0);
	else
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -9e-82], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.7e-102], N[(N[(N[(0.0 - b), $MachinePrecision] - N[Sqrt[N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(N[(b / a), $MachinePrecision] + N[(N[(b / a), $MachinePrecision] + N[(N[(c * -2.0), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -8.9999999999999997e-82

   1. Initial program 13.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 86.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 86.3%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -8.9999999999999997e-82 < b < 1.70000000000000006e-102

   1. Initial program 76.7%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around 0

      \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\color{blue}{\left(-4 \cdot \left(a \cdot c\right)\right)}\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]
   4. Step-by-step derivation

      1. associate-*r* N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\left(\left(-4 \cdot a\right) \cdot c\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      2. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\left(c \cdot \left(-4 \cdot a\right)\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      3. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \left(-4 \cdot a\right)\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \left(a \cdot -4\right)\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      5. *-lowering-*.f64 75.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \mathsf{*.f64}\left(a, -4\right)\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

   5. Simplified 75.6%

      \[\leadsto \frac{\left(-b\right) - \sqrt{\color{blue}{c \cdot \left(a \cdot -4\right)}}}{2 \cdot a} \]

   if 1.70000000000000006e-102 < b

   1. Initial program 68.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 68.0%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   6. Applied egg-rr 68.2%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\frac{b}{a}, -0.5, \frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{\frac{a}{-0.5}}\right)} \]
   7. Step-by-step derivation

      1. +-commutative N/A

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

      2. associate-/r/ N/A

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

      3. distribute-rgt-out N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \color{blue}{\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a} + \frac{b}{a}\right)}\right) \]

      5. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a}\right), \color{blue}{\left(\frac{b}{a}\right)}\right)\right) \]

   8. Applied egg-rr 68.2%

      \[\leadsto \color{blue}{-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(-4 \cdot c\right)}}{a} + \frac{b}{a}\right)} \]

   9. Taylor expanded in c around 0

      \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\color{blue}{\left(-2 \cdot \frac{c}{b} + \frac{b}{a}\right)}, \mathsf{/.f64}\left(b, a\right)\right)\right) \]
   10. Step-by-step derivation

       1. +-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{b}{a} + -2 \cdot \frac{c}{b}\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       2. +-lowering-+.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\left(\frac{b}{a}\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       3. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       4. associate-*r/ N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(\frac{-2 \cdot c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       5. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(-2 \cdot c\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       6. *-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(c \cdot -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       7. *-lowering-*.f64 94.8%

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\mathsf{*.f64}\left(c, -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

   11. Simplified 94.8%

       \[\leadsto -0.5 \cdot \left(\color{blue}{\left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)} + \frac{b}{a}\right) \]
3. Recombined 3 regimes into one program.

4. Final simplification 86.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -9 \cdot 10^{-82}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 1.7 \cdot 10^{-102}:\\ \;\;\;\;\frac{\left(0 - b\right) - \sqrt{c \cdot \left(a \cdot -4\right)}}{a \cdot 2}\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 80.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -9 \cdot 10^{-77}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 2.1 \cdot 10^{-103}:\\ \;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{c \cdot \left(a \cdot -4\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -9e-77)
   (- 0.0 (/ c b))
   (if (<= b 2.1e-103)
     (* (/ -0.5 a) (+ b (sqrt (* c (* a -4.0)))))
     (* -0.5 (+ (/ b a) (+ (/ b a) (/ (* c -2.0) b)))))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -9e-77) {
		tmp = 0.0 - (c / b);
	} else if (b <= 2.1e-103) {
		tmp = (-0.5 / a) * (b + sqrt((c * (a * -4.0))));
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-9d-77)) then
        tmp = 0.0d0 - (c / b)
    else if (b <= 2.1d-103) then
        tmp = ((-0.5d0) / a) * (b + sqrt((c * (a * (-4.0d0)))))
    else
        tmp = (-0.5d0) * ((b / a) + ((b / a) + ((c * (-2.0d0)) / b)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -9e-77) {
		tmp = 0.0 - (c / b);
	} else if (b <= 2.1e-103) {
		tmp = (-0.5 / a) * (b + Math.sqrt((c * (a * -4.0))));
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -9e-77:
		tmp = 0.0 - (c / b)
	elif b <= 2.1e-103:
		tmp = (-0.5 / a) * (b + math.sqrt((c * (a * -4.0))))
	else:
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)))
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -9e-77)
		tmp = Float64(0.0 - Float64(c / b));
	elseif (b <= 2.1e-103)
		tmp = Float64(Float64(-0.5 / a) * Float64(b + sqrt(Float64(c * Float64(a * -4.0)))));
	else
		tmp = Float64(-0.5 * Float64(Float64(b / a) + Float64(Float64(b / a) + Float64(Float64(c * -2.0) / b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -9e-77)
		tmp = 0.0 - (c / b);
	elseif (b <= 2.1e-103)
		tmp = (-0.5 / a) * (b + sqrt((c * (a * -4.0))));
	else
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -9e-77], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.1e-103], N[(N[(-0.5 / a), $MachinePrecision] * N[(b + N[Sqrt[N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(N[(b / a), $MachinePrecision] + N[(N[(b / a), $MachinePrecision] + N[(N[(c * -2.0), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if b < -9.0000000000000001e-77

   1. Initial program 13.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 86.3%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 86.3%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -9.0000000000000001e-77 < b < 2.10000000000000005e-103

   1. Initial program 76.7%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 76.5%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   5. Taylor expanded in b around 0

      \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\color{blue}{\left(-4 \cdot \left(a \cdot c\right)\right)}\right)\right)\right) \]
   6. Step-by-step derivation

      1. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\left(\left(a \cdot c\right) \cdot -4\right)\right)\right)\right) \]

      2. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\left(\left(c \cdot a\right) \cdot -4\right)\right)\right)\right) \]

      3. associate-*r* N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\left(c \cdot \left(a \cdot -4\right)\right)\right)\right)\right) \]

      4. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\left(c \cdot \left(-4 \cdot a\right)\right)\right)\right)\right) \]

      5. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \left(-4 \cdot a\right)\right)\right)\right)\right) \]

      6. *-commutative N/A

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \left(a \cdot -4\right)\right)\right)\right)\right) \]

      7. *-lowering-*.f64 75.4%

         \[\leadsto \mathsf{*.f64}\left(\mathsf{/.f64}\left(\frac{-1}{2}, a\right), \mathsf{+.f64}\left(b, \mathsf{sqrt.f64}\left(\mathsf{*.f64}\left(c, \mathsf{*.f64}\left(a, -4\right)\right)\right)\right)\right) \]

   7. Simplified 75.4%

      \[\leadsto \frac{-0.5}{a} \cdot \left(b + \sqrt{\color{blue}{c \cdot \left(a \cdot -4\right)}}\right) \]

   if 2.10000000000000005e-103 < b

   1. Initial program 68.2%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 68.0%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   6. Applied egg-rr 68.2%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\frac{b}{a}, -0.5, \frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{\frac{a}{-0.5}}\right)} \]
   7. Step-by-step derivation

      1. +-commutative N/A

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

      2. associate-/r/ N/A

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

      3. distribute-rgt-out N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \color{blue}{\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a} + \frac{b}{a}\right)}\right) \]

      5. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a}\right), \color{blue}{\left(\frac{b}{a}\right)}\right)\right) \]

   8. Applied egg-rr 68.2%

      \[\leadsto \color{blue}{-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(-4 \cdot c\right)}}{a} + \frac{b}{a}\right)} \]

   9. Taylor expanded in c around 0

      \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\color{blue}{\left(-2 \cdot \frac{c}{b} + \frac{b}{a}\right)}, \mathsf{/.f64}\left(b, a\right)\right)\right) \]
   10. Step-by-step derivation

       1. +-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{b}{a} + -2 \cdot \frac{c}{b}\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       2. +-lowering-+.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\left(\frac{b}{a}\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       3. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       4. associate-*r/ N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(\frac{-2 \cdot c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       5. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(-2 \cdot c\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       6. *-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(c \cdot -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       7. *-lowering-*.f64 94.8%

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\mathsf{*.f64}\left(c, -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

   11. Simplified 94.8%

       \[\leadsto -0.5 \cdot \left(\color{blue}{\left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)} + \frac{b}{a}\right) \]
3. Recombined 3 regimes into one program.

4. Final simplification 86.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -9 \cdot 10^{-77}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{elif}\;b \leq 2.1 \cdot 10^{-103}:\\ \;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{c \cdot \left(a \cdot -4\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 68.4% accurate, 5.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-310}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -2e-310)
   (- 0.0 (/ c b))
   (* -0.5 (+ (/ b a) (+ (/ b a) (/ (* c -2.0) b))))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-2d-310)) then
        tmp = 0.0d0 - (c / b)
    else
        tmp = (-0.5d0) * ((b / a) + ((b / a) + ((c * (-2.0d0)) / b)))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -2e-310:
		tmp = 0.0 - (c / b)
	else:
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)))
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -2e-310)
		tmp = Float64(0.0 - Float64(c / b));
	else
		tmp = Float64(-0.5 * Float64(Float64(b / a) + Float64(Float64(b / a) + Float64(Float64(c * -2.0) / b))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -2e-310)
		tmp = 0.0 - (c / b);
	else
		tmp = -0.5 * ((b / a) + ((b / a) + ((c * -2.0) / b)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -2e-310], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(N[(b / a), $MachinePrecision] + N[(N[(b / a), $MachinePrecision] + N[(N[(c * -2.0), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.999999999999994e-310

   1. Initial program 32.6%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 64.5%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 64.5%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -1.999999999999994e-310 < b

   1. Initial program 68.4%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   4. Applied egg-rr 68.2%

      \[\leadsto \color{blue}{\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\right)} \]

   6. Applied egg-rr 68.4%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\frac{b}{a}, -0.5, \frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{\frac{a}{-0.5}}\right)} \]
   7. Step-by-step derivation

      1. +-commutative N/A

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

      2. associate-/r/ N/A

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

      3. distribute-rgt-out N/A

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

      4. *-lowering-*.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \color{blue}{\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a} + \frac{b}{a}\right)}\right) \]

      5. +-lowering-+.f64 N/A

         \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{\sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}}{a}\right), \color{blue}{\left(\frac{b}{a}\right)}\right)\right) \]

   8. Applied egg-rr 68.4%

      \[\leadsto \color{blue}{-0.5 \cdot \left(\frac{\sqrt{b \cdot b + a \cdot \left(-4 \cdot c\right)}}{a} + \frac{b}{a}\right)} \]

   9. Taylor expanded in c around 0

      \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\color{blue}{\left(-2 \cdot \frac{c}{b} + \frac{b}{a}\right)}, \mathsf{/.f64}\left(b, a\right)\right)\right) \]
   10. Step-by-step derivation

       1. +-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\left(\frac{b}{a} + -2 \cdot \frac{c}{b}\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       2. +-lowering-+.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\left(\frac{b}{a}\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(\color{blue}{b}, a\right)\right)\right) \]

       3. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(-2 \cdot \frac{c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       4. associate-*r/ N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \left(\frac{-2 \cdot c}{b}\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       5. /-lowering-/.f64 N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(-2 \cdot c\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       6. *-commutative N/A

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\left(c \cdot -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

       7. *-lowering-*.f64 81.1%

          \[\leadsto \mathsf{*.f64}\left(\frac{-1}{2}, \mathsf{+.f64}\left(\mathsf{+.f64}\left(\mathsf{/.f64}\left(b, a\right), \mathsf{/.f64}\left(\mathsf{*.f64}\left(c, -2\right), b\right)\right), \mathsf{/.f64}\left(b, a\right)\right)\right) \]

   11. Simplified 81.1%

       \[\leadsto -0.5 \cdot \left(\color{blue}{\left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)} + \frac{b}{a}\right) \]
3. Recombined 2 regimes into one program.

4. Final simplification 71.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-310}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{else}:\\ \;\;\;\;-0.5 \cdot \left(\frac{b}{a} + \left(\frac{b}{a} + \frac{c \cdot -2}{b}\right)\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 68.5% accurate, 9.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-310}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{else}:\\ \;\;\;\;\frac{c}{b} - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -2e-310) (- 0.0 (/ c b)) (- (/ c b) (/ b a))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = (c / b) - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-2d-310)) then
        tmp = 0.0d0 - (c / b)
    else
        tmp = (c / b) - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = (c / b) - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -2e-310:
		tmp = 0.0 - (c / b)
	else:
		tmp = (c / b) - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -2e-310)
		tmp = Float64(0.0 - Float64(c / b));
	else
		tmp = Float64(Float64(c / b) - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -2e-310)
		tmp = 0.0 - (c / b);
	else
		tmp = (c / b) - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -2e-310], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.999999999999994e-310

   1. Initial program 32.6%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 64.5%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 64.5%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -1.999999999999994e-310 < b

   1. Initial program 68.4%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in c around 0

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

      1. +-commutative N/A

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

      2. mul-1-neg N/A

         \[\leadsto \frac{c}{b} + \left(\mathsf{neg}\left(\frac{b}{a}\right)\right) \]

      3. unsub-neg N/A

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

      4. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(\left(\frac{c}{b}\right), \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      5. /-lowering-/.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(\mathsf{/.f64}\left(c, b\right), \left(\frac{\color{blue}{b}}{a}\right)\right) \]

      6. /-lowering-/.f64 81.1%

         \[\leadsto \mathsf{\_.f64}\left(\mathsf{/.f64}\left(c, b\right), \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 81.1%

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

Alternative 8: 68.3% accurate, 11.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-310}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (if (<= b -2e-310) (- 0.0 (/ c b)) (- 0.0 (/ b a))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= (-2d-310)) then
        tmp = 0.0d0 - (c / b)
    else
        tmp = 0.0d0 - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= -2e-310) {
		tmp = 0.0 - (c / b);
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= -2e-310:
		tmp = 0.0 - (c / b)
	else:
		tmp = 0.0 - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= -2e-310)
		tmp = Float64(0.0 - Float64(c / b));
	else
		tmp = Float64(0.0 - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= -2e-310)
		tmp = 0.0 - (c / b);
	else
		tmp = 0.0 - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, -2e-310], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < -1.999999999999994e-310

   1. Initial program 32.6%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{c}{b}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{c}{b}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{c}{b}\right)}\right) \]

      4. /-lowering-/.f64 64.5%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(c, \color{blue}{b}\right)\right) \]

   5. Simplified 64.5%

      \[\leadsto \color{blue}{0 - \frac{c}{b}} \]

   if -1.999999999999994e-310 < b

   1. Initial program 68.4%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{b}{a}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      4. /-lowering-/.f64 80.4%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 80.4%

      \[\leadsto \color{blue}{0 - \frac{b}{a}} \]
   6. Step-by-step derivation

      1. sub0-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-lowering-neg.f64 N/A

         \[\leadsto \mathsf{neg.f64}\left(\left(\frac{b}{a}\right)\right) \]

   7. Applied egg-rr 80.4%

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

4. Final simplification 71.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq -2 \cdot 10^{-310}:\\ \;\;\;\;0 - \frac{c}{b}\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 44.1% accurate, 11.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b \leq 2.4 \cdot 10^{-299}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c) :precision binary64 (if (<= b 2.4e-299) 0.0 (- 0.0 (/ b a))))

C

double code(double a, double b, double c) {
	double tmp;
	if (b <= 2.4e-299) {
		tmp = 0.0;
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: tmp
    if (b <= 2.4d-299) then
        tmp = 0.0d0
    else
        tmp = 0.0d0 - (b / a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double tmp;
	if (b <= 2.4e-299) {
		tmp = 0.0;
	} else {
		tmp = 0.0 - (b / a);
	}
	return tmp;
}

Python

def code(a, b, c):
	tmp = 0
	if b <= 2.4e-299:
		tmp = 0.0
	else:
		tmp = 0.0 - (b / a)
	return tmp

Julia

function code(a, b, c)
	tmp = 0.0
	if (b <= 2.4e-299)
		tmp = 0.0;
	else
		tmp = Float64(0.0 - Float64(b / a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	tmp = 0.0;
	if (b <= 2.4e-299)
		tmp = 0.0;
	else
		tmp = 0.0 - (b / a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := If[LessEqual[b, 2.4e-299], 0.0, N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < 2.40000000000000019e-299

   1. Initial program 33.0%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around -inf

      \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \color{blue}{\left(-1 \cdot b\right)}\right), \mathsf{*.f64}\left(2, a\right)\right) \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \left(\mathsf{neg}\left(b\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      2. neg-sub0 N/A

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \left(0 - b\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

      3. --lowering--.f64 17.6%

         \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{\_.f64}\left(0, b\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

   5. Simplified 17.6%

      \[\leadsto \frac{\left(-b\right) - \color{blue}{\left(0 - b\right)}}{2 \cdot a} \]
   6. Step-by-step derivation

      1. div-sub N/A

         \[\leadsto \frac{\mathsf{neg}\left(b\right)}{2 \cdot a} - \color{blue}{\frac{0 - b}{2 \cdot a}} \]

      2. neg-sub0 N/A

         \[\leadsto \frac{\mathsf{neg}\left(b\right)}{2 \cdot a} - \frac{\mathsf{neg}\left(b\right)}{\color{blue}{2} \cdot a} \]

      3. +-inverses 17.6%

         \[\leadsto 0 \]

   7. Applied egg-rr 17.6%

      \[\leadsto \color{blue}{0} \]

   if 2.40000000000000019e-299 < b

   1. Initial program 68.1%

      \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
   2. Add Preprocessing

   3. Taylor expanded in b around inf

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

      1. mul-1-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-sub0 N/A

         \[\leadsto 0 - \color{blue}{\frac{b}{a}} \]

      3. --lowering--.f64 N/A

         \[\leadsto \mathsf{\_.f64}\left(0, \color{blue}{\left(\frac{b}{a}\right)}\right) \]

      4. /-lowering-/.f64 81.1%

         \[\leadsto \mathsf{\_.f64}\left(0, \mathsf{/.f64}\left(b, \color{blue}{a}\right)\right) \]

   5. Simplified 81.1%

      \[\leadsto \color{blue}{0 - \frac{b}{a}} \]
   6. Step-by-step derivation

      1. sub0-neg N/A

         \[\leadsto \mathsf{neg}\left(\frac{b}{a}\right) \]

      2. neg-lowering-neg.f64 N/A

         \[\leadsto \mathsf{neg.f64}\left(\left(\frac{b}{a}\right)\right) \]

   7. Applied egg-rr 81.1%

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

4. Final simplification 43.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b \leq 2.4 \cdot 10^{-299}:\\ \;\;\;\;0\\ \mathbf{else}:\\ \;\;\;\;0 - \frac{b}{a}\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 11.1% accurate, 116.0× speedup

Math

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

FPCore

(FPCore (a b c) :precision binary64 0.0)

C

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

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = 0.0d0
end function

Java

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

Python

def code(a, b, c):
	return 0.0

Julia

function code(a, b, c)
	return 0.0
end

MATLAB

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

Wolfram

code[a_, b_, c_] := 0.0

Derivation

1. Initial program 47.3%

   \[\frac{\left(-b\right) - \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}}{2 \cdot a} \]
2. Add Preprocessing

3. Taylor expanded in b around -inf

   \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \color{blue}{\left(-1 \cdot b\right)}\right), \mathsf{*.f64}\left(2, a\right)\right) \]
4. Step-by-step derivation

   1. mul-1-neg N/A

      \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \left(\mathsf{neg}\left(b\right)\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

   2. neg-sub0 N/A

      \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \left(0 - b\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

   3. --lowering--.f64 11.4%

      \[\leadsto \mathsf{/.f64}\left(\mathsf{\_.f64}\left(\mathsf{neg.f64}\left(b\right), \mathsf{\_.f64}\left(0, b\right)\right), \mathsf{*.f64}\left(2, a\right)\right) \]

5. Simplified 11.4%

   \[\leadsto \frac{\left(-b\right) - \color{blue}{\left(0 - b\right)}}{2 \cdot a} \]
6. Step-by-step derivation

   1. div-sub N/A

      \[\leadsto \frac{\mathsf{neg}\left(b\right)}{2 \cdot a} - \color{blue}{\frac{0 - b}{2 \cdot a}} \]

   2. neg-sub0 N/A

      \[\leadsto \frac{\mathsf{neg}\left(b\right)}{2 \cdot a} - \frac{\mathsf{neg}\left(b\right)}{\color{blue}{2} \cdot a} \]

   3. +-inverses 11.4%

      \[\leadsto 0 \]

7. Applied egg-rr 11.4%

   \[\leadsto \color{blue}{0} \]
8. Add Preprocessing

Developer Target 1: 70.4% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sqrt{b \cdot b - 4 \cdot \left(a \cdot c\right)}\\ \mathbf{if}\;b < 0:\\ \;\;\;\;\frac{c}{a \cdot \frac{\left(-b\right) + t\_0}{2 \cdot a}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\left(-b\right) - t\_0}{2 \cdot a}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (let* ((t_0 (sqrt (- (* b b) (* 4.0 (* a c))))))
   (if (< b 0.0)
     (/ c (* a (/ (+ (- b) t_0) (* 2.0 a))))
     (/ (- (- b) t_0) (* 2.0 a)))))

C

double code(double a, double b, double c) {
	double t_0 = sqrt(((b * b) - (4.0 * (a * c))));
	double tmp;
	if (b < 0.0) {
		tmp = c / (a * ((-b + t_0) / (2.0 * a)));
	} else {
		tmp = (-b - t_0) / (2.0 * a);
	}
	return tmp;
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sqrt(((b * b) - (4.0d0 * (a * c))))
    if (b < 0.0d0) then
        tmp = c / (a * ((-b + t_0) / (2.0d0 * a)))
    else
        tmp = (-b - t_0) / (2.0d0 * a)
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double t_0 = Math.sqrt(((b * b) - (4.0 * (a * c))));
	double tmp;
	if (b < 0.0) {
		tmp = c / (a * ((-b + t_0) / (2.0 * a)));
	} else {
		tmp = (-b - t_0) / (2.0 * a);
	}
	return tmp;
}

Python

def code(a, b, c):
	t_0 = math.sqrt(((b * b) - (4.0 * (a * c))))
	tmp = 0
	if b < 0.0:
		tmp = c / (a * ((-b + t_0) / (2.0 * a)))
	else:
		tmp = (-b - t_0) / (2.0 * a)
	return tmp

Julia

function code(a, b, c)
	t_0 = sqrt(Float64(Float64(b * b) - Float64(4.0 * Float64(a * c))))
	tmp = 0.0
	if (b < 0.0)
		tmp = Float64(c / Float64(a * Float64(Float64(Float64(-b) + t_0) / Float64(2.0 * a))));
	else
		tmp = Float64(Float64(Float64(-b) - t_0) / Float64(2.0 * a));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	t_0 = sqrt(((b * b) - (4.0 * (a * c))));
	tmp = 0.0;
	if (b < 0.0)
		tmp = c / (a * ((-b + t_0) / (2.0 * a)));
	else
		tmp = (-b - t_0) / (2.0 * a);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(4.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[Less[b, 0.0], N[(c / N[(a * N[(N[((-b) + t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-b) - t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]

Reproduce

herbie shell --seed 2024191 
(FPCore (a b c)
  :name "The quadratic formula (r2)"
  :precision binary64

  :alt
  (! :herbie-platform default (let ((d (sqrt (- (* b b) (* 4 (* a c)))))) (let ((r1 (/ (+ (- b) d) (* 2 a)))) (let ((r2 (/ (- (- b) d) (* 2 a)))) (if (< b 0) (/ c (* a r1)) r2)))))

  (/ (- (- b) (sqrt (- (* b b) (* 4.0 (* a c))))) (* 2.0 a)))