Python Program To Solve Quadratic Equations (With Code Examples)

A quadratic equation is a polynomial equation with a maximum degree of two. It takes the form ax² + bx + c = 0, where a, b, and c are constant terms, and x is the unknown variable. Quadratic equations (i.e., equations of degree two) are a fundamental algebraic concept frequently encountered in mathematics, physics, engineering, programming, etc. In this article, we will explore how to write a Python program to solve quadratic equations using various techniques offered by this dynamically typed programming language.

What Is A Quadratic Equation? How To Solve It?

As mentioned at the beginning, a quadratic equation is a polynomial equation with a maximum degree of two. Since this is a second-degree equation, there will be two solutions or roots, which can be found using the quadratic equation formula. That is, for the quadratic equation is ax^2 + bx + c = 0, the formula to get its roots is:

x = [-b±√(b^2-4ac)]/2a

There will be two solutions to the problem of x, according to the plus/minus sign. Here, the expression (b^2 - 4ac) is often referred to as the discriminant (D), which determines the nature of the roots. There are three possibilities for D and subsequent roots, as follows:

• D > 0, roots are real and distinct (unequal)
• D = 0, roots are real and equal (coincident)
• D < 0, roots are imaginary and unequal

Let's take an overview of how to solve the quadratic equation. For example, we want to solve the equation 2x^2 - 5x + 2 = 0. Then-

We will apply the components of the equation, i.e., a = 2, b = -5, c = 2 can be put in the quadratic formula equation, i.e., x = ((-(b) ((b2 - 4ac))) / 2a. The expression can be solved as follows:

x = (-( -5) ± √((-5)^2 - 4 * 2 * 2)) / (2 * 2)
x = (5 ± √(25 - 16)) / 4
x = (5 ± √9) / 4, where (√9 = 3)

We then get two roots, root 1 (plus sign) and root 2 (minus sign), as follows:

x = (5 + 3) / 4 and x = (5 - 3) / 4
x = 8 / 4 and x = 2 / 4
x = 2 and x = 1/2

To solve a quadratic equation using the quadratic formula, you must first compute the expression (discriminant) contained within the square root. Next, you must evaluate both roots by placing positive and negative signs in front of the square root to get the answers for x.

How To Write A Python Program To Solve Quadratic Equations?

Quadratic functions form the basis of complex mathematical topics. Here’s a basic approach to writing a Python program to solve quadratic equations:

Step 1- Get user input for equation coefficients (a, b, c): When solving for user-generated input, the first step is to prompt the user to provide values for the coefficients a, b, and c of the quadratic equation. This is done using the input() function, and any conversions are made using float().

Step 2- Check coefficient for equality with zero: Once we have all the coefficient values, we check if they are equal to zero. This helps determine the nature of the solution, i.e., if a=0, then the equation is linear with one root= -b; if b=0, then the equation will have two imaginary roots; and if c=0, then the equation will have two distinct roots. 

Step 3- Calculate discriminant: If all coefficients are positive non-zero numbers, then we calculate the discriminant using the quadratic formula.

# Calculate discriminant
D = b^2 - 4ac

Step 3- Calculate the roots: Use the discriminant to calculate the roots and print them using the print() function.

Now that we know the basic logic behind the Python program to solve quadratic equations let's take a look at a sample Python program that showcases its implementation.

Code Example:

Output:

Code Explanation:

In the sample Python code-

1. We begin by importing the math module and then prompt the user to provide values for the three coefficients of the quadratic equation.
2. Here, we use the input() function to get the value and the float() function to convert the input values to floating-point numbers before storing them in respective variables.
3. Next, we use nested if-else statements to check if any of the coefficient values are zero and determine the nature of the roots thereof.
   • In the outermost statement, we check if a is zero using the relational equality operator. If the condition a==0 is false, the corresponding else-block is executed to calculate the discriminant (D) and flow moves to the next line after the if-else statement.  
   • If the condition is true, we move to the next if-else statement and check if b==0. If the condition is false, then a single root is calculated and printed with a string message.
   • If both a and b are zero, we move to the innermost if-block to check if c == 0. The corresponding string message is printed depending on where the condition is true or false.
4. In the nested if-else, if a is not equal to zero, we calculate the discriminant and then the roots. For this, we employ an if-elif-else statement.
5. Here, if D>0, then we have two distinct real roots. We calculate the roots using the quadratic formula and print the same to the console using the print() function.
6. Else-if D==0, then we have one real root which is also calculated and printed to the console. 
7. Or else, we have complex roots whose complex and real parts are calculated and displayed on the console using the print() function.
8. In the output window above, we have compiled a table of different input possibilities and corresponding output for roots.

Also read: Python IDLE | The Ultimate Beginner's Guide With Images & Codes!

Python Program To Solve Quadratic Equations Directly Using The Formula

We can directly use the quadratic formula when writing a Python program to solve quadratic equations. This is a straightforward approach to finding the roots of quadratic expressions. By implementing the quadratic formula within the program, users can input the coefficients of a quadratic equation, and the program computes the solutions directly. This method bypasses the need for manual calculation and reduces the likelihood of errors.

Below is an example Python program that uses this approach to solve the quadratic equation.

Code Example:

Output:

Enter coefficient a: 9
Enter coefficient b: 3
Enter coefficient c: 2
Two complex roots:
Root 1: -0.16666666666666666 + 0.44095855184409843 i
Root 2: -0.16666666666666666 - 0.44095855184409843 i

Code Explanation:

In the example Python code-

1. We start by prompting the user to enter the coefficients a, b, and c of a quadratic equation. These coefficients are stored in variables with corresponding names.
2. Then, we use these values and apply them to the quadratic formula to calculate the discriminant, which is stored in variable D. 
3. Next, we use an if-else statement to check if the coefficient a (the one multiplying the highest power term) is zero, i.e., condition a==0.
   • If the condition is true, the equation technically isn't quadratic, so the code handles this as a special case by printing out a string message to the same effect.
   • If the condition is false, the else block is executed to calculate the two roots and the outcomes are stored in variables root1 and root2.
4. If coefficient a is not zero, it means we do have solutions for the quadratic equation. The nature of the roots is then determined using the value of variable D.
5. For this, we use an if-elif-else statement where-
6. If the discriminant is positive, there are two distinct real number solutions, which we calculated above. We print these to the console using a set of print() statements.
   • If the discriminant is zero, we have repeated the real number solution, which is printed to the console. 
   • If the discriminant is negative, the solutions are complex numbers (containing the imaginary unit iota). We use the specific formula to calculate the roots for this case and display them to the console. 

Python Program To Solve Quadratic Equations Using The Complex Math Module

We can use the complex math module from the Python library and the functions it contains to solve a quadratic equation with complex roots. By utilizing this module's capabilities, we can write a Python program to solve quadratic equations with negative discriminants, enabling the determination of complex solutions.

This approach ensures robustness in handling quadratic equations with complex coefficients. Here, we can encapsulate the logic for solving the quadratic solving within a function to enhance code organization and reusability. Let's look at a sample Python solution/ program that applies this approach.

Code Example:

Output:

Enter the coefficient a: 8
Enter the coefficient b: 6
Enter the coefficient c: 4
The solutions are (-0.375-0.5994789404140899j) and (-0.375+0.5994789404140899j)

Explanation:

In the Python code example-

1. We first import the cmath library, which helps work with complex numbers. This will be useful for solutions that aren't real numbers.
2. Then, we define a function named solve_quadratic that takes three numbers as input, i.e., a (coefficient of the highest power term), b (coefficient of the middle term), and c (constant term).
   • This function is designed to find the solutions (roots) of the quadratic equation based on these coefficients.
   • It first calculates the discriminant using the basic formula, and the outcome is stored in the variable discriminant. 
   • Next, it uses the discriminant to calculate the two roots, and the outcomes are stored in variables solution1 and solution2, which the function returns.
   • It is important to note that we are assuming that the solutions will be complex, so we use the sqrt() function from the cmath module when calculating the roots.
3. After that, we define a block that ensures that the code inside is executed only if the script is run directly, not when it is imported as a module.
4. Inside the block, we use the input() function to prompt the user to provide values for the coefficients a, b, and c. The values are converted to floating-point using float() and stored in the respective variables.
5. Next, we call the solve_quadratic() function with the user-provided input values as arguments. Note that we are assuming the coefficients provided will lead to complex roots.
6. The function returns the solutions, which are stored in solution1 and solution2.
7. Finally, the code prints a message that shows both solutions in a formatted way using the print() function.

Python Program To Solve Quadratic Equations Using Functions

We can define a custom function to solve quadratic equations and use it to write a Python program. This approach helpz us write a program that is structured to streamline the process of finding the roots of quadratic expressions. This encapsulation of functionality enhances code readability and reusability as users can call the function with different coefficient values to obtain the solutions for any quadratic equation.

Additionally, incorporating error handling within the function ensures robustness, enabling the program to handle scenarios like division by zero or invalid inputs gracefully. Overall, this approach offers a concise and modular way of writing a Python program to solve quadratic equations, facilitating ease of use and maintenance. Let's dive into a Python program example to understand the implementation of this approach.

Code Example:

Output:

Enter coefficient a: 7
Enter coefficient b: 4
Enter coefficient c: 8
Two complex roots:
Root: (-0.2857142857142857+1.0301575072754254j)
Root: (-0.2857142857142857-1.0301575072754254j)

Explanation:

In the Python code sample-

1. We first import the math module to use its functionalities for calculations, especially square roots.
2. Then, we define a function named quadratic_roots that takes three numbers as input, i.e., the coefficients and finds the solutions (roots) of the quadratic equation based on these coefficients.
3. Inside the function, we use the quadratic formula to calculate the discriminant which is stored inside the D variable. This will be used to calculate and determine the nature of the solutions/ roots.
4. The function also contains an if-statement, which checks if the coefficient a is zero. If a is zero, the equation isn't a true quadratic equation, and the function returns an error message. We do not check for other coefficients because even if they are zero, the roots will still exist.
5. If a is not zero, we move to the next part of the function. Here, we use the if-elif-else statement to determine the nature of the roots, calculate them, and print them to the console.
   • If the discriminant is positive, there are two distinct real number solutions, which are found using a formula. The function returns these solutions and a message together.
   • If the discriminant is zero, there's one repeated real number solution, which is calculated using another formula. The function returns this solution and a message together.
   • If the discriminant is negative, we will have complex solutions. The function calculates these roots and returns these complex solutions along with a message.
6. After defining the function, we ask the user to enter the coefficient values for a, b, and c.
7. Then, we call the quadratic_roots() function with the user-provided coefficients.
8. The function does the calculations and returns a result based on the solutions it finds. The outcome is stored in the result variable.
9. We then use an if-statement to check the result variable and display an output based on that. here-
   • If the result is a group of values (like a list), it means that roots exits. The code separates and prints the message about the solutions followed by each root value on a new line.
   • If the result is a string message/ text, it means that there is no viable solution for the quadratic equation or an issue during the calculation (e.g., non-zero 'a' is required). The code prints this message using the print() function.

Python Program To Solve Quadratic Equations & Find Number Of Solutions

Ideally, a quadratic equation of the form ax² + bx + c = 0 must have one or more roots, either real or complex. Calculating the discriminant (D) of a quadratic equation, which is given by the formula D = b**2 - 4*a*c, is necessary to determine the number of solutions and their nature. The discriminant provides details on the roots' nature as follows:

• The equation has two unique real roots if D > 0.
• The equation has one real root (repeated) if D = 0.
• The equation contains two complex roots if D < 0.

Below is an example of a Python program that shows how we can use the value of D to determine the number of roots a quadratic equation has.

Code Example:

Output:

Enter coefficient a: 5
Enter coefficient b: 7
Enter coefficient c: 2
The quadratic equation has two distinct real solutions.

Explanation:

In the Python example code-

1. We first prompt the user to enter the coefficients (a, b, and c) of a quadratic equation. These coefficients are stored in variables for easy use later.
2. Next, we calculate a value called the discriminant and store it in the variable D. This value is important because it helps us determine how many solutions the quadratic equation has. The discriminant is calculated using a formula: b**2 - 4*a*c.
3. Based on the value of the discriminant, we can figure out the number of solutions. For this, we use an if-elif-else statement where-
   • If the discriminant is positive, i.e., D > 0, there are two distinct real number solutions. Then, the variable num_solutions is assigned a value of 2.
   • If the discriminant is zero, i.e., D == 0, there's one repeated real number solution (the same value appears twice), and the num_solutions variable is assigned a value of 1.
   • If the discriminant is negative, i.e., D < 0, there are no real number solutions, but there might be complex solutions. In this case, the num_solutions variable is assigned a value of 0.
4. Next, we analyse the value of the num_solutions variable to determine the number of roots and print a message for the same. 
5. For this, we use another if-elif-else statement, where if num_solutions == 2, the print() statement inside the if-block displays the message- The quadratic equation has two distinct real solutions, to the console.
6. Else-if, num_solutions == 1, the program prints the string message- The quadratic equation has one real solution (repeated).
7. Or else, if num_solutions == 0, the program prints- The quadratic equation has no real solutions.
8. In the example and output, since the user-provided values are taken to be 5, 7 and 2, there will be two real roots. This means the value of num_solutions variable is 2, and the if-block prints the corresponding message to the console.

Python Program To Plot Quadratic Functions

A Python interactive data visualization tool called Matplotlib uses JavaScript and HTML to render its charts. It is designed to be presented in current web browsers and offers innovative graphics that are elegantly constructed, succinctly written, and interactively powerful.

On a graph, quadratic curves may be drawn using Matplotlib. By providing the right data points and equations, you can often construct many sorts of charts, including quadratic curves, by using methods like plot() and scatter(). In this section, we will take a look at the code to plot the quadratic curve of the equation- x^2 - 3x + 2.

Code Example:

Output:

This program will plot a quadratic function, and you will need the Matplotlib module to view it.

Graph:

Explanation:

In the example above-

1. We first import libraries to work with numbers, i.e., numpy and create visuals, i.e., matplotlib.
2. Then, we define a function named quadratic_function() that takes x (independent variable) and coefficients a, b, and c of the quadratic equation. It calculates the y-value for a given x and returns it.
3. Next, we set the range for the x-axis using a function that creates an array of x-values between -10 and 10 with 400 points (more points make a smoother curve), i.e., np.linspace(-10, 10, 400).
4. We then create three variables a, b, and c to represent the coefficients of the quadratic function we want to visualize, and assign values 1, -3, and 2 to them, respectively. 
5. After that, we call the quadratic_function() function with the x-values and coefficients to calculate corresponding y-values for each x, resulting in an array of y-values representing the function's output.
6. As mentioned in the code comment, we then create a new window for the graph using the figure() function from the matpotlib module and provide a size for it, i.e., figsize.
7. Following this, we use a set of functions from the module to specify other details of the graph. We use plt.plot() to draw the line representing the function based on the x and y values we calculated. A label showing the specific equation is also added.
8. The plt.axhline() and plt.axvline() specify the details of the lines, i.e., dashed lines are drawn at y=0 (x-axis) and x=0 (y-axis) to help visualize where the function intersects these axes.
9. We use functions plt.xlabel(), plt.ylabel(), and plt.title() to name the axes and the graph.
10. Then, we use the plt.legend() function to create the legend using the labels and other details and plt.grid() to add a grid for better readability.
11. Finally, we use the plt.show() function to display the generated plot on the screen, showing the visualization of the quadratic function.

Conclusion

We have discussed various approaches to writing a Python program to solve quadratic equations. The built-in libraries and mathematical methods contained simplify the process of solving quadratic equations in Python programming. The libraries like NumPy and SymPy, together with the simplicity of coding, make it possible to compute solutions with real and complex roots and visualize the results with accuracy and efficiency. Developers may leverage core mathematical concepts as well as libraries like NumPy and math to build robust programs that swiftly calculate roots and assist efficient problem-solving. 

Frequently Asked Questions

Q. What is a quadratic equation, and why is it important?

A quadratic equation is a polynomial equation of the second degree, typically written in the standard form ax² + bx + c = 0, where a, b, and c are coefficients, and x is the variable. It's important because it represents many real-world phenomena and is fundamental in various fields such as physics, engineering, economics, and computer science.

Q. How does the Python program utilize the quadratic formula to solve quadratic equations?

In a Python program to solve quadratic equations, we can define a function, say, solve_quadratic(a, b, c), that takes the coefficients, a, b, and c, as input and returns the solutions using the quadratic formula. It calculates the discriminant, determines the type of roots based on its value, and computes the solutions accordingly, handling both real and complex roots.

Q. How do I handle complex roots in Python when solving quadratic equations?

In Python, handling complex roots when solving quadratic equations involves using the cmath module, which provides support for complex numbers. Here's a simple example demonstrating how to handle complex roots in Python:

Code Example:

Output:

Root 1: -1.0
Root 2: -1.0

Explanation: 

In this code:

• We import the cmath module to handle complex numbers.
• Inside the solve_quadratic function, we first calculate the discriminant.
• If the discriminant is negative, indicating complex roots, we use cmath.sqrt() to compute the square root.
• If the discriminant is non-negative, indicating real roots, we use the regular sqrt() function.
• We return both roots as a tuple.
• Finally, we provide example coefficients and print out the roots.

Q. Can you use Python to solve equations?

Equations, differential equations, linear equations, nonlinear equations, matrix problems, inequalities, Diophantine equations, and integral evaluation can all be solved symbolically using the SymPy Python library.

By fusing mathematics with computer science through the use of mathematical symbols, symbolic computation in Sympy is used to solve mathematical equations.

It works with mathematical formulas and objects. Using conventional mathematical symbols, Sympy evaluates algebraic statements precisely but not roughly.

Q. Can Python solve a quadratic equation?

Yes, Python has a variety of tools and libraries that it can use to solve quadratic equations. SymPy is a popular library for symbolic mathematics, which can be used to solve equations, particularly quadratic equations. Let’s take a look at an example Python program to solve quadratic equations using the SymPy modue.

Code Example:

Output:

Solutions: [2, 3]

Explanation:

1. Using sp, we import the Sympy library.
2. Using sp.symbols('x'), we define the symbol x. In our equation, this symbol will stand in for the variable.
3. We use the polynomial expression quadratic_eq to define the quadratic equation.
4. To resolve the quadratic equation for x, we employ the sp.solve() function.
5. A list of solutions is returned by the function.
6. The answers are printed out.

We have discussed multiple variations of the Python program to solve quadratic equations. Here are a few more interesting topics you must explore:

1. Python Logical Operators, Short-Circuiting & More (With Examples)
2. How To Reverse A String In Python? 10 Easy Ways With Examples!
3. Python For Loop | Syntax & Application (With Multiple Examples)
4. 12 Ways To Compare Strings In Python Explained (With Examples)
5. Python Bitwise Operators | Positive & Negative Numbers (+Examples)