This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.
Write a program to find the roots of a quadratic equation, i.e., solve the equation 



a

x

2


+
b
x
+
c
=
0


{\displaystyle ax^{2}+bx+c=0}

.
Your program must correctly handle non-real roots, but it need not check that 



a
≠
0


{\displaystyle a\neq 0}

.

The problem of solving a quadratic equation is a good example of how dangerous it can be to ignore the peculiarities of floating-point arithmetic.
The obvious way to implement the quadratic formula suffers catastrophic loss of accuracy when one of the roots to be found is much closer to 0 than the other.
In their classic textbook on numeric methods Computer Methods for Mathematical Computations, George Forsythe, Michael Malcolm, and Cleve Moler suggest trying the naive algorithm with 



a
=
1


{\displaystyle a=1}

, 



b
=
−

10

5




{\displaystyle b=-10^{5}}

, and 



c
=
1


{\displaystyle c=1}

.
(For double-precision floats, set 



b
=
−

10

9




{\displaystyle b=-10^{9}}

.)
Consider the following implementation in Ada:

with Ada.Text_IO;                        use Ada.Text_IO;
with Ada.Numerics.Elementary_Functions;  use Ada.Numerics.Elementary_Functions;
 
procedure Quadratic_Equation is
   type Roots is array (1..2) of Float;
   function Solve (A, B, C : Float) return Roots is
      SD : constant Float := sqrt (B**2 - 4.0 * A * C);
      AA : constant Float := 2.0 * A;
   begin
      return ((- B + SD) / AA, (- B - SD) / AA);
   end Solve;
 
   R : constant Roots := Solve (1.0, -10.0E5, 1.0);
begin
   Put_Line ("X1 =" & Float'Image (R (1)) & " X2 =" & Float'Image (R (2)));
end Quadratic_Equation;

Output:
X1 = 1.00000E+06 X2 = 0.00000E+00
As we can see, the second root has lost all significant figures. The right answer is that X2 is about 




10

−
6




{\displaystyle 10^{-6}}

. The naive method is numerically unstable.

Suggested by Middlebrook (D-OA), a better numerical method: to define two parameters 



q
=


a
c



/

b


{\displaystyle q={\sqrt {ac}}/b}

 and 



f
=
1

/

2
+


1
−
4

q

2





/

2


{\displaystyle f=1/2+{\sqrt {1-4q^{2}}}/2}



and the two roots of the quardratic are: 






−
b

a


f


{\displaystyle {\frac {-b}{a}}f}

 and 






−
c


b
f





{\displaystyle {\frac {-c}{bf}}}




Task: do it better. This means that given 



a
=
1


{\displaystyle a=1}

, 



b
=
−

10

9




{\displaystyle b=-10^{9}}

, and 



c
=
1


{\displaystyle c=1}

, both of the roots your program returns should be greater than 




10

−
11




{\displaystyle 10^{-11}}

. Or, if your language can't do floating-point arithmetic any more precisely than single precision, your program should be able to handle 



b
=
−

10

6




{\displaystyle b=-10^{6}}

. Either way, show what your program gives as the roots of the quadratic in question. See page 9 of
"What Every Scientist Should Know About Floating-Point Arithmetic" for a possible algorithm.

 
1) using lambdas:
 
{def equation
 {lambda {:a :b :c}
  {b equation :a*x{sup 2}+:b*x+:c=0}
  {{lambda {:a' :b' :d}
   {if {> :d 0}
   then {{lambda {:b' :d'}          
         {equation.disp {+ :b' :d'} {- :b' :d'} 2 real roots}
        } :b' {/ {sqrt :d} :a'}}
   else {if {< :d 0}
   then {{lambda {:b' :d'} 
         {equation.disp [:b',:d'] [:b',-:d'] 2 complex roots}
        } :b' {/ {sqrt {- :d}} :a'} }
   else {equation.disp :b'  :b' one real double root}
  }}
  } {* 2 :a} {/ {- :b} {* 2 :a}} {- {* :b :b} {* 4 :a :c}} } }} 
 
2) using let:
 
{def equation
 {lambda {:a :b :c}
  {b equation :a*x{sup 2}+:b*x+:c=0}
  {let { {:a' {* 2 :a}}
         {:b' {/ {- :b} {* 2 :a}}}
         {:d  {- {* :b :b} {* 4 :a :c}}} }
   {if {> :d 0}
    then {let { {:b' :b'}
                {:d' {/ {sqrt :d} :a'}} }
          {equation.disp {+ :b' :d'} {- :b' :d'} 2 real roots} }
    else {if {< :d 0}
    then {let { {:b' :b'}
                {:d' {/ {sqrt {- :d}} :a'}} } 
          {equation.disp [:b',:d'] [:b',-:d'] 2 complex roots} } 
    else  {equation.disp :b' :b' one real double root} }} }}}
 
3) a function to display results in an HTML table format
 
{def equation.disp
 {lambda {:x1 :x2 :txt}
  {table {@ style="background:#ffa"} 
   {tr {td :txt:    }}
   {tr {td x1 = :x1 }} 
   {tr {td x2 = :x2 }} } }}
 
4) testing:
 
equation 1*x2+1*x+-1=0 
2 real roots:
 x1 = 0.6180339887498949
 x2 = -1.618033988749895
 
equation 1*x2+1*x+1=0 
2 complex roots:
 x1 = [-0.5,0.8660254037844386]
 x2 = [-0.5,-0.8660254037844386]
 
equation 1*x2+-2*x+1=0 
one real double root:
 x1 = 1
 x2 = 1
 