Question

A complex number is a number of the form a + bi, where a and b are real numbers √

and i is −1. The numbers a and b are known as the real and the imaginary parts, respectively, of the complex number.

The operations addition, subtraction, multiplication, and division for complex num- bers are defined as follows:

(a+bi)+(c+di) = (a+c)+(b+d)i

(a+bi)−(c+di) = (a−c)+(b−d)i (a + bi) ∗ (c + di) = (ac − bd) + (bc + ad)i

(a + bi)/(c + di) = (ac + bd) + (bc − ad)i (c2 + d2) (c2 + d2)

The absolute value for a complex number is given by: |a+bi|= a2 +b2

A complex number a + bi can be interpreted as a point on a plane by identifying the (a, b) values as the coordinates of a point in two dimensions. The absolute value of the complex number corresponds to the distance of the point to the origin (0, 0).

Python has the complex class for performing complex number arithmetic. Here, you will design and implement your own class to represent complex numbers and do operations on complex numbers.

In a file called complex.py, create a class named Complex for representing complex numbers, including overriding special methods for addition ( add ), subtraction ( sub ), multiplication ( mul ), division ( truediv ), and absolute value ( abs ). Also include a str method that returns a string representation for a complex number a + bi as “(a+bi)”. If b is 0, str must return a.

Provide a constructor for the Complex class that has two optional parameters, say a and b, to create the complex number a + bi; the default values for a and b is 0. Also provide the accessor methods getRealPart() and getImaginaryPart() for returning the real and imaginary parts of the complex number, respectively.

Write a main function to test your Complex class by prompting the user to enter the real and imaginary parts of two complex numbers and displaying the results of calling each method.

Answer 1

class Complex:

        # Constructor
        def __init__(self, re=0.0, im=0.0):
                self._re = re
                self._im = im

        # Return the real part of self.
        def getRealPart(self):
                return self._re

        # Return the imaginary part of self.
        def getImaginaryPart(self):
                return self._im

        # Return the conjugate of self.
        def conjugate(self):
                return Complex(self._re, -self._im)

        def __add__(self, other):
                if type(other) == int or type(other) == float:
                        return Complex(self._re + other, self._im)

                re = self._re + other._re
                im = self._im + other._im
                return Complex(re, im)

        def __radd__(self, other):
                return Complex(self._re + other, self._im)

        def __sub__(self, other):
                if type(other) == int or type(other) == float:
                        return Complex(self._re - other, self._im)

                re = self._re - other._re
                im = self._im - other._im
                return Complex(re, im)

        def __rsub__(self, other):
                return Complex(-self._re + other, -1 * self._im)

        def __mul__(self, other):
                if type(other) == int or type(other) == float:
                        return Complex(self._re * other, self._im * other)

                re = self._re * other._re - self._im * other._im
                im = self._re * other._im + self._im * other._re
                return Complex(re, im)

        def __rmul__(self, other):
                return Complex(self._re * other, self._im * other)

        def __truediv__(self, other):
                if type(other) == int or type(other) == float:
                        return Complex(self._re / other, self._im / other)

                conjugate = other.conjugate()
                numerator = self * conjugate
                multiple = conjugate * other
                multiple = multiple._re

                numerator._re /= multiple
                numerator._im /= multiple
                
                return numerator

        def __rtruediv__(self, other):
                conjugate = self.conjugate()

                multiple = conjugate * self
                conjugate._re *= other
                conjugate._im *= other
                
                conjugate._re /= multiple._re
                conjugate._im /= multiple._re
                return conjugate


        # Return a string representation of self.
        def __str__(self):
                if self._re == 0:
                        return str(self._im) + 'i'
                if self._im == 0:
                        return str(self._im)
                if self._im < 0:
                        return  str(self._re) + ' - ' + str(abs(self._im)) + 'i'

                return str(self._re) + ' + ' + str(self._im) + 'i'

        def __repr__(self):
                return 'Complex(' + str(self._re) + ', ' + str(self._im) + ')'

        
a = int(input('Enter real part of first number: '))
b = int(input('Enter imaginary part of first number: '))
c1 = Complex(a, b)
a = int(input('Enter real part of second number: '))
b = int(input('Enter imaginary part of second number: '))
c2 = Complex(a, b)

print(c1 + c2)
print(c1 - c2)
print(c1 * c2)
print(c1 / c2)
print(c1 - 2)
print(2 - c2)

Please upvote, as i have given the exact answer as asked in question. Still in case of any concerns in code, let me know in comments. Thanks!