पायथन में कॉम्प्लेक्स नंबर ऑब्जेक्ट्स के लिए क्लास परिभाषित करने का प्रोग्राम

मान लीजिए हम निम्न ऑपरेशंस के साथ एक कॉम्प्लेक्स नंबर क्लास परिभाषित करके कॉम्प्लेक्स नंबर के कार्य करना चाहते हैं:

add() दो कॉम्प्लेक्स नंबर जोड़ने के लिए
sub() दो कॉम्प्लेक्स नंबर घटाने के लिए
mul() दो कॉम्प्लेक्स नंबर गुणा करने के लिए
div() दो कॉम्प्लेक्स नंबर विभाजित करने के लिए
mod() कॉम्प्लेक्स नंबर का मॉड्यूलस प्राप्त करने के लिए

कॉम्प्लेक्स नंबर (a + bi) के रूप में दिखाए जाएंगे। हमारे पास दो कॉम्प्लेक्स नंबर हैं, हम उन पर ये ऑपरेशन करेंगे। क्लास के अंदर हम add(), sub(), mul() और div() मेथड्स को ओवरलोड करते हैं ताकि हम ऑपरेटर्स का उपयोग करके ऑपरेशन कर सकें। हम __str__() मेथड को भी ओवरलोड करते हैं ताकि कॉम्प्लेक्स नंबर को उचित रूप में प्रिंट किया जा सके।

उदाहरण के लिए, यदि इनपुट c1 = 2+3i c2 = 5-2i है, तो आउटपुट (7.00 + 1.00i), (-3.00 + 5.00i), (16.00 + 11.00i), (0.14 + 0.66i), 3.61, 5.39 होगा।

समाधान दृष्टिकोण

इसे हल करने के लिए हम निम्न चरणों का पालन करेंगे:

real part re और imaginary part im के साथ कॉम्प्लेक्स क्लास परिभाषित करें
add() फंक्शन परिभाषित करें। यह o लेगा
- (re + o.re, im + o.im) के साथ एक नया कॉम्प्लेक्स ऑब्जेक्ट लौटाएं
sub() फंक्शन परिभाषित करें। यह o लेगा
- (re - o.re, im - o.im) के साथ एक नया कॉम्प्लेक्स ऑब्जेक्ट लौटाएं
mul() फंक्शन परिभाषित करें। यह o लेगा
- (re * o.re - im * o.im, re * o.im + im * o.re) के साथ एक नया कॉम्प्लेक्स ऑब्जेक्ट लौटाएं
div() फंक्शन परिभाषित करें। यह o लेगा
- m := o.re * o.re + o.im * o.im
- ((re * o.re + im * o.im)/m, (im * o.re - re * o.im)/m) के साथ एक नया कॉम्प्लेक्स नंबर ऑब्जेक्ट लौटाएं
mod() फंक्शन परिभाषित करें। यह लेगा
- (re * re + im * im) का वर्गमूल लौटाएं
__str__() ओवरलोड करें।
- यदि im 0 के समान है, तो re को दो दशमलव स्थानों तक लौटाएं
- यदि re 0 के समान है, तो im को दो दशमलव स्थानों तक लौटाएं
- यदि im < 0, तो re - im i लौटाएं, दोनों (re और im दो दशमलव स्थानों तक)
- अन्यथा, re + im i लौटाएं, दोनों (re और im दो दशमलव स्थानों तक)

उदाहरण

बेहतर समझ के लिए निम्न कार्यान्वयन देखें:

from math import sqrt

class Complex:
    def __init__(self, real, imag):
        self.re = real
        self.im = imag
    
    def __add__(self, o):
        return Complex(self.re+o.re, self.im+o.im)
    
    def __sub__(self, o):
        return Complex(self.re-o.re, self.im-o.im)
    
    def __mul__(self, o):
        return Complex(self.re*o.re-self.im*o.im, self.re * o.im + self.im * o.re)
    
    def __truediv__(self, o):
        m = o.re * o.re + o.im * o.im
        return Complex((self.re * o.re + self.im * o.im)/m, (self.im * o.re - self.re * o.im)/m)
    
    def __str__(self):
        if self.im == 0:
            return '%.2f' % self.re
        if self.re == 0:
            return '%.2fi' % self.im
        if self.im < 0:
            return '%.2f - %.2fi' % (self.re, -self.im)
        else:
            return '%.2f + %.2fi' % (self.re, self.im)
    
    def mod(self):
        return sqrt(self.re*self.re+self.im*self.im)

def solve(comp1, comp2):
    print(comp1 + comp2)
    print(comp1 - comp2)
    print(comp1 * comp2)
    print(comp1 / comp2)
    print('%.2f' % comp1.mod())
    print('%.2f' % comp2.mod())

comp1 = Complex(2, 3)
comp2 = Complex(5, -2)
solve(comp1, comp2)

इनपुट

2, 3 5, -2

आउटपुट

7.00 + 1.00i -3.00 + 5.00i 16.00 + 11.00i 0.14 + 0.66i 3.61 5.39