Quadratic (Python recipe) by Fouad Teniou

ActiveState Code (http://code.activestate.com/recipes/576407/)

I don't understand why there are so many "args.get('X')". And this OOP-style __str__ is not consistent with the non-OOP-style __call__. Here is another version:

import math, cmath

def polynome2str(*factors): # Greatest power to smallest
    def lmonome(factor, degree):
        if not factor:
            return ()
        if factor > 0:
            sign = "+"
        else:
            sign = "-"
            factor = -factor            
        if degree == 0:
            x = ""
        elif degree == 1:
            x = "x"
        else:
            x = "x^%d" % degree
        if degree > 0 and factor in (-1, 1): factor = ""
        return (sign, "%s%s" % (factor, x))

    result = []
    for f, d in zip(factors, range(len(factors)-1, -1, -1)):
        result += list(lmonome(f, d))
    if len(result) > 1 and result[0] == "+": result = result[1:]
    return " ".join(result)


class Quadratic:
    a, b, c   = None, None, None
    degree    = None
    solutions = None

    def __init__(self, **args):
        self.a = a = args.get("a", 0)
        self.b = b = args.get("b", 0)
        self.c = c = args.get("c", 0)
        self.degree = 2
        delta = b**2 - 4.*a*c
        if a == 0:
            assert b != 0, "Not an equation: %s = 0" % c
            # Linear equation
            self.degree = 1
            self.solutions = (-c / b,)
        elif delta == 0:
            self.solutions = (-b / (2.*a),)
        elif delta > 0:
            s = math.sqrt(delta)
            self.solutions = ( (-b - s) / (2.*a), (-b + s) / (2.*a) )
        else: # delta < 0 => complex solution
            s = cmath.sqrt(delta)
            self.solutions = ( (-b - s) / (2.*a), (-b + s) / (2.*a) )

    def __str__(self):
        a, b, c = (self.a, self.b, self.c)
        if self.degree == 1:
            return "Linear equation %s = 0, solution is: %s" \
                   % (polynome2str(b, c), self.solutions[0])
        s = polynome2str(a, b, c)
        if len(self.solutions) == 1:
            return "Quadratic equation %s = %s.(%s)^2 = 0, unique solution is: %s"\
                   % (s, a, polynome2str(1, b/(2.*a)), self.solutions[0])
        else:
            t = (s,) + self.solutions
            return "Quadratic equation %s = 0, solutions are: %s and %s" % t


if __name__ =='__main__':
        y = Quadratic(a=7,b=-2,c=-2)
        print y
        y = Quadratic(a=-1,b=4,c=-5)
        print y
        y = Quadratic(a=4,b=-4,c=1)
        print y
        y = Quadratic(a=0,b=3,c=3)
        print y

What does "#On the name of ALLAH" have to do with Python?

Thank you for your comment David Decotiny However, the args.get('a'),('b'),('c')are calling the dictionary values by keys once the user input them to perform the quadratic operations solutions -b(+ -)square-root(b^2 - 4ac)/2a. and if you look at my Pycol program where I used the OOP style you can see that I used the __repr__ for printing but not in this program because it works better. However, you can use both, it will depend of the order you want the execution of your program and the outcome The __call__ is made for calling the class directly instead of defining it by other name say( eg if I defined it as equation : if __name__=='__main__' y=Quadratic() y.equation(a=?,b=?,c=?) print y I hope that you will see the difference and will realise why I called it directly.

I use on the name of ALLAH because I am a Muslim and that is the way we write or say before we start doing things such as ( studying or eating ) for God bounty and I hope you will do one day yourself and see the difference of performing any task in your life, thus, On the name of ALLAH does have nothing to do with python and as you can realise that is not part of the code.

Fixed a bug and normalized output to complex numbers.

import math
import cmath

def solve_quadratic_equation(a, b, c):
    roots = []
    try:
        if a != 0:
            discriminant = b**2 - 4*a*c
            neg_b_div_2a = -(b/(2*a))
            if discriminant > 0:
                sqrt_discriminant_div_2a = math.sqrt(discriminant)/2*a
                roots.append(complex(neg_b_div_2a + sqrt_discriminant_div_2a, 0))
                roots.append(complex(neg_b_div_2a - sqrt_discriminant_div_2a, 0))
            elif discriminant == 0:
                roots.append(complex(neg_b_div_2a, 0))
            else:
                sqrt_discriminant_div_2a = cmath.sqrt(-discriminant)/2*a
                roots.append(complex(neg_b_div_2a, sqrt_discriminant_div_2a))
                roots.append(complex(neg_b_div_2a, -sqrt_discriminant_div_2a))
        else:
            raise Exception, "a == 0"
    except Exception, e:
        print("%s: %s" % ("solve_quadratic_equation failed", e))
    return roots

if __name__ =='__main__':
    print solve_quadratic_equation(1, 0, -64)
    print solve_quadratic_equation(1, 0, 64)
    print solve_quadratic_equation(1, 4, 4)
    print solve_quadratic_equation(0, 0, 64)

Hmm...not sure why the comment editor switched my comments and timestamps around. #5 should be my second post.

This recipe is entirely unreadable and current version fails at line 20. (And it's revision 12.)

The intention here is to solve an equation. I don't see the need to get fancy and create a class, make it a callable object and override __str__. Plus the values of a, b, c should be extracted once to variables as David D. recommended.

If one wants to check the input or format the output, I suggest those be done separately. Here's my version which makes the math pretty clear.

import math
import cmath

def solve_quadratic_equation(a, b, c):
    roots = []
    try:
        if a != 0:
            discriminant = b**2 - 4*a*c
            neg_b_div_2a = -(b/(2*a))
            if discriminant > 0:
                sqrt_discriminant_div_2a = math.sqrt(discriminant)/2*a
                roots.append(neg_b_div_2a + sqrt_discriminant_div_2a)
                roots.append(neg_b_div_2a - sqrt_discriminant_div_2a)
            elif discriminant == 0:
                roots.append(neg_b_div_2a)
            else:
                sqrt_discriminant_div_2a = cmath.sqrt(-discriminant)/2*a
                roots.append(complex(neg_b_div_2a, sqrt_discriminant_div_2a))
                roots.append(complex(neg_b_div_2a, sqrt_discriminant_div_2a))
        else:
            print("%s: %s" % ("solve_quadratic_equation failed", "a == 0"))
    except Exception, e:
        print("%s: %s" % ("solve_quadratic_equation failed", e))
    return roots

if __name__ =='__main__':
    print solve_quadratic_equation(1, 0, -64)
    print solve_quadratic_equation(1, 0, 64)

You should know that I am using a Central Library for posting my programs and therefore I tried to use Word document, cut and pace from my original version, which I wrote and which is working perfectly and providing professional outcome, and which I tested on DOS before I posted it. However, I noticed there is a bracket missing on line 20 and 25 and I expect people as your self to be able to correct such anomalies since they are out of control sometimes while the Word cut and pace process is not working especially here at the Central Library which I do have to use for personal reasons. I used the Class method, because this is the way I do write my programs, ( Fancy ways) and people do have different style even in what they eat or the way they do it. Though people will import the class or use it as part of other programs, because this is the Mathematics branch, and people use for different purpose ( Finance ,Statistics, Accounting etc,etc………………………………. Quadratic is a superb program and is working perfectly and other students and Tutors will find it extremely useful whether to check or to rely on for their professional work. I realised that you used exceptions on your version and again this is up to people to choose their style, and I do not see the need of raising exceptions because Python raise exceptions automatically with their own wordings. I use the if statement which I believe is more professional and the is the best style, since it is based on logic which is a branch in Mathematics and which is the branch I did study and gain an International Baccalaureate in 1987

If 4 a c is much less than b squared then the formula, for roots while mathematically correct is numerically poor. See this link for better logic:

http://thornahawk.unitedti.org/

You should have read the comment on the top of the program ( if b^2-4ac is negative the solutions are not real but complex numbers of the form a+bj. Though, both real and complex solutions are called using Quadratic) we get the complex number solution. However, as you should be aware of the use of complex numbers in the mathematic field. And I even noticed in the web link you mentioned that there is a reference to people want to use the complex solutions which could be for higher levels in mathematics field

Try and stick with an __init__ method . . . I understand you have a degree in math but you should ALWAYS stick with defining classes that confine to the OOP paradigm. Also try and make your code more readable by making it more concise.