Python provides an inbuilt module
```
math
```

that comes with many mathematical methods to perform mathematical operations. But many mathematical operations can not be performed on negative numbers or zeros. For example, there is no normal number square root for negative numbers. And when we try to pass negative numbers to math methods like sqrt() and log(), we receive the Error
```
ValueError: math domain error
```

.

In this Python tutorial, we will learn why this error arises in a Program and solve it. In this tutorial, we will also walk through an example that demonstrates this error in a Python pogrom, so you can better understand how to solve this error for yourself. So let's get started with the error statement.

##
**
Python Problem ValueError: math domain error
**

The Python
```
math
```

module is inherited from the C programming language math library, and it contains all the mathematical operation methods. But some methods in the math modules can not work with negative numbers and return the "ValueError: math domain error" Error. Let's break the error statement into two parts

- ValueError
- math domain error

###
**
1. ValueError
**

The ValueError is one of the standard Python Exceptions. The value error is raised in a Python program when we pass a valid data type as an argument but a wrong data value. For example, in the case of
```
math.sqrt()
```

method, it can accept positive numbers but can not accept negative numbers and throws errors.

###
**
2. math domain error
**

This is the error message telling us that there is some error with the math module method. And we receive this error because we must be passing a negative number to the
```
math.sqrt()
```

or
```
math.log()
```

methods.

**
Example
**

```
import math
# initialize a negetive number
num = -3
# find square root of num
square_root = math.sqrt(num)
print(f"Square root of {num} is: ", math.sqrt(num))
```

**
Output
**

```
Traceback (most recent call last):
File "main.py", line 7, in
square_root = math.sqrt(num)
ValueError: math domain error
```

In the above example, we are getting this error because we are trying to find the square root of a negative number
```
num
```

using the
```
math.sqrt()
```

method. The
```
math.sqrt()
```

method can not compute the square root for negative numbers and throw the
```
ValueError: math domain error
```

Error. Not only the
```
sqrt
```

method, but the
```
log()
```

method also returns the
```
ValueError: math domain error
```

error when a negative number is passed as an argument.

##
**
Common Example Scenario
**

Let's say we are creating a square root Python program that accepts a number from the user and return the square root of the number.

###
**
Example
**

```
import math
# input the number
num = int(input("Enter the number: "))
# find square root of num
square_root = math.sqrt(num)
print(f"Square root of {num} is: ", square_root)
```

####
**
Output
**

```
Enter the number: -4
Traceback (most recent call last):
File "main.py", line 7, in
square_root = math.sqrt(num)
ValueError: math domain error
```

**
Break the code
**

In the above example, we are getting the Error because the user entered
```
-4
```

as an input value. And the
```
math.sqrt()
```

method can not compute the square root of negative numbers, that's why we are receiving this error.

##
**
Solution
**

There are two approaches we can use to solve the above example problem.

###
**
Approach 1
**

In the first approach, we can check if the user entered number is a negative number, and print the message that the program does not accept the negative number.

**
Example solution
**

```
import math
# input the number
num = int(input("Enter the number: "))
# if num is a negative number
if num <0:
print("Program does not accept negative numbers ")
else:
# find square root of num
square_root = math.sqrt(num)
print(f"Square root of {num} is: ", square_root )
```

**
Output
**

```
Enter the number: -5
Program does not accept negative numbers
```

###
**
Approach 2
**

We can also find the square root for the negative numbers in mathematics, but the result will be an imaginary or complex number. In Python, we also have the concept of complex numbers that can be represented using
```
num + numj
```

. Python also supports a
```
cmath
```

module that stands for complex math module. It is similar to the math module and also contains the same methods but returns a complex number instead of a real number. Using the
```
cmath.sqrt()
```

methods, we can also find the square root for the negative numbers.

**
Example solution
**

```
# import complex math module
import cmath
# input the number
num = int(input("Enter the number: "))
square_root = cmath.sqrt(num)
print(f"Square root of {num} is: ", square_root)
```

**
Output
**

```
Enter the number: -6
Square root of -6 is: 2.449489742783178j
```

##
**
Conclusion
**

The "ValueError: math domain error" is not a common error, and you will only be encountering this error when you are dealing with
```
math
```

module. This error is raised in a Python program when we pass a negative number to such math module methods that do not accept negative numbers.

To solve this error, you can either use the check statements to check if the number is negative or not. Or you can use the
```
cmath
```

module that supports all the methods of the math module and does not return the ValueError: math domain error for negative numbers. If you are still getting this error in your Python program, please share your code and query in the comment section. We will try to help you in debugging.

**
People are also reading:
**

- Python TypeError: ‘>’ not supported between instances of ‘str’ and ‘int’ Solution
- How To Do Math in Python 3 with Operators?
- Python TypeError: ‘list’ object cannot be interpreted as an integer Solution
- What can you do with Python?
- Python Number, Type Conversion and Mathematics
- A Guide to Flatten List in Python
- Python median() A statistics Method
- Enumerate in Python
- Python AttributeError: A Complete Guide
- Global Keyword in Python

## Leave a Comment on this Post