Question

C++ CLASS FOR DEFINING COMPLEX NUMBERS (READ BELOW)

Write a C++ defining a class for complex numbers. A complex number is a number of the form: a + b ∗ i , where, for our purposes, a and b are numbers of type double, and i is a number that represents the quantity √ −1. You should represent a complex number here as two values of type double. You should name the variables real and imaginary. You can call the class Complex. You should include a constructor with two parameters of type double that can be used to set the member variables of an object to any values. You can also include a default constructor that initializes the object to 0 (that is to 0+ 0*i). Now, you should overload all of the following operators so that they correctly apply to the type Complex: ==, +, -, >>, and <<. You should write a test program to test your class. Hints: To add or subtract two complex numbers, you should add or subtract two member variables of type double. The product of two complex numbers is given by the following formula: (a + b ∗ i) ∗ (c + d ∗ i) = (a ∗ c − b ∗ d) + (a ∗ d + b ∗ c) ∗ i Sample Input and Output: complex number x = (3, -4) real part: 3 imaginary part: -4 complex number y = (1, -1) real part: 1 imaginary part: -1 z = x + y = (4, -5) z = x * y = (-1, -7) z = x - y = (2, -3)

Answer 1

#include<iostream>

#include<cstring>

#include<cmath>

#include <sstream>

using namespace std;

class Complex

{

    double real;

    double imaginary;

   

    public:

        

        // default constructor

        Complex()

        {

            real = 1;

            imaginary = 0;

        }

       

        // overloaded constructor

        Complex(double real)

        {

            this->real = real;

            this->imaginary = 0;

        }

       

        // overloaded constructor

        Complex(double real, double imaginary)

        {

            this->real = real;

            this->imaginary = imaginary;

        }

       

        // copy constructor

        Complex(const Complex& ob)

        {

            this->real = ob.real;//ob.getReal();

            this->imaginary = ob.imaginary;//ob.getImaginary();

        }

       

        // destructor

        ~Complex()

        {

           

        }

       

        // getter methods

       

        double getReal()

        {

            return this->real;

        }

       

        double getImaginary()

        {

            return this->imaginary;

        }

       

        // setter methods

       

        void setReal(double real)

        {

            this->real = real;

        }

       

        void setImaginary(double imaginary)

        {

            this->imaginary = imaginary;

        }

       

        // returns the complex modulus (or complex norm) of the object

        double Modulus()

        {

            return sqrt(real * real + imaginary * imaginary);

        }

       

        Complex Complement()

        {

            // create a new Complex object

            Complex ans;

           

            ans.setReal(this->getReal());

           

            ans.setImaginary(-this->getImaginary());

           

            return ans;

        }

       

        Complex operator+(Complex ob)

        {

            // create a new Complex object

            Complex ans;

           

            // compute the real part of the resulting complex number

            ans.setReal(this->getReal() + ob.getReal());

           

            // compute the imaginary part of the resulting complex number

           ans.setImaginary(this->getImaginary() + ob.getImaginary());

           

            return ans;

        }

       

        Complex operator-(Complex ob)

        {

            // create a new Complex object

            Complex ans;

           

            // compute the real part of the resulting complex number

            ans.setReal(this->getReal() - ob.getReal());

           

            // compute the imaginary part of the resulting complex number

            ans.setImaginary(this->getImaginary() - ob.getImaginary());

           

            return ans;

        }

       

        Complex operator*(Complex ob)

        {

            // create a new Complex object

            Complex ans;

           

            // compute the real part of the resulting complex number

            ans.setReal(this->getReal() * ob.getReal() - this->getImaginary() * ob.getImaginary());

           

            // compute the imaginary part of the resulting complex number

            ans.setImaginary(this->getReal() * ob.getImaginary() + this->getImaginary() * ob.getReal());

           

            return ans;

        }

       

        Complex operator/(Complex ob)

        {

            // get the modulous of ob

            int mod = ob.Modulus();

           

            if(mod == 0)

                throw "Error: Cannot divide by zero.";

           

            // create a new Complex object which is complement of ob

            Complex comp = ob.Complement();

           

            // get a new Complex number which is the product of the current

            // object and the complement of ob

            Complex temp = (*this) * comp;

           

           

            // create a new Complex object which is the required ans

            Complex ans;

           

            // compute the real part of the resulting complex number

            ans.setReal(temp.getReal() / mod);

           

            // compute the imaginary part of the resulting complex number

            ans.setImaginary(temp.getImaginary() / mod);

           

            return ans;

        }

       

        string toString()

        {

            stringstream x;

           

            x<<this->getReal();

           

            string ans = x.str();

            if(this->getImaginary() > 0)

                ans += " + ";

            else

                ans += " - ";

               

            stringstream y;

           

            y<<abs(this->getImaginary());

           

            ans += y.str() + "i";

           

            return ans;

        }

       

        // overload ==

        bool operator==(Complex& ob)

        {

            return this->getReal() == ob.getReal() && this->getImaginary() == ob.getImaginary();

        }

       

        // overload !=

        bool operator!=(Complex& ob)

        {

            return !(*this == ob);

        }

       

        // overload <

        bool operator<(Complex& ob)

        {

            return this->Modulus() < ob.Modulus();

        }

       

        // overload !=

        bool operator>(Complex& ob)

        {

            return this->Modulus() > ob.Modulus();

        }

       

        // overload <<

        friend istream& operator>>(istream &in, Complex &ob)

        {

            cout<<"real : ";

            in>>ob.real;

           

            cout<<"imaginary : ";

            in>>ob.imaginary;

           

            return in;

        }

       

        // overload <<

        friend ostream& operator<<(ostream &out, Complex &ob)

        {

            out<<"( "<<ob.real<<" + "<<ob.imaginary<<" i )";

           

            return out;

        }

};

int main()

{

    Complex ob1;

   

    cin>>ob1;

   

    cout<<"\nob1 : "<<ob1<<"\n\n";

   

    Complex ob2;

   

    cin>>ob2;

   

    cout<<"\nob2 : "<<ob2<<"\n\n";

   

    Complex ob3 = ob1 + ob2;

    cout<<"\n\nob1 + ob2 : "<<ob3.toString()<<endl;

   

    Complex ob4 = ob1 - ob2;

    cout<<"\n\nob1 - ob2 : "<<ob4.toString()<<endl;

   

    Complex ob5 = ob1 * ob2;

    cout<<"\n\nob1 * ob2 : "<<ob5.toString()<<endl;

   

    Complex ob6 = ob1 / ob2;

    cout<<"\n\nob1 / ob2 : "<<ob6.toString()<<endl<<endl;

   

    cout<<"\nob1 == ob2 : "<<(ob1==ob2);

   

    return 0;

}

Sample Output

In case of any issue, please leave a comment and I will resolve your issue.