Question

A complex number is a number in the form a + bi, where a and b are real numbers and i is sqrt( -1). The numbers a and b are known as the real part and imaginary part of the complex number, respectively.

You can perform addition, subtraction, multiplication, and division for complex numbers using the following formulas:

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)/(c^2 +d^2) + (bc-ad)i/(c^2 +d^2)

You can also obtain the absolute value for a complex number using the following formula:

| a + bi | = sqrt(a^2 + b^2)

(A complex number can be interpreted as a point on a plane by identifying the (a, b) values as the coordinates of the point. The absolute value of the complex number corresponds to the distance of the point to the origin, as shown in Figure 13.10.)

Design a class named Complex for representing complex numbers and the methods add, subtract, multiply, divide, and abs for performing complex number operations, and override the toString method for returning a string representation for a complex number. The toString method returns (a + bi) as a string. If b is 0, it simply returns a. Your Complex class should also implement Cloneable and Comparable. Compare two complex numbers using their absolute values.

Provide three constructors Complex(a, b), Complex(a), and Complex(). Complex() creates a Complex object for number 0 and Complex(a) creates a Complex object with 0 for b. Also provide the getRealPart() and getImaginaryPart() methods for returning the real and imaginary part of the complex number, respectively.

Use the code at

https://liveexample.pearsoncmg.com/test/Exercise13_17.txt

to test your implementation.

Sample Run

Enter the first complex number: 3.5 5.5

Enter the second complex number: -3.5 1

(3.5 + 5.5i) + (-3.5 + 1.0i) = 0.0 + 6.5i

(3.5 + 5.5i) - (-3.5 + 1.0i) = 7.0 + 4.5i

(3.5 + 5.5i) * (-3.5 + 1.0i) = -17.75 -15.75i

(3.5 + 5.5i) / (-3.5 + 1.0i) = -0.5094339622641509 -1.7169811320754718i

|3.5 + 5.5i| = 6.519202405202649

false

3.5

5.5

[-3.5 + 1.0i, 4.0 + -0.5i, 3.5 + 5.5i, 3.5 + 5.5i]

so I did like this:

import java.util.Scanner;

public class Exercise13_17 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter the first complex number: ");
double a = input.nextDouble();
double b = input.nextDouble();
Complex c1 = new Complex(a, b);

System.out.print("Enter the second complex number: ");
double c = input.nextDouble();
double d = input.nextDouble();
Complex c2 = new Complex(c, d);

System.out.println("(" + c1 + ")" + " + " + "(" + c2 + ")" + " = " + c1.add(c2));
System.out.println("(" + c1 + ")" + " - " + "(" + c2 + ")" + " = " + c1.subtract(c2));
System.out.println("(" + c1 + ")" + " * " + "(" + c2 + ")" + " = " + c1.multiply(c2));
System.out.println("(" + c1 + ")" + " / " + "(" + c2 + ")" + " = " + c1.divide(c2));
System.out.println("|" + c1 + "| = " + c1.abs());

Complex c3 = (Complex) c1.clone();
System.out.println(c1 == c3);
System.out.println(c3.getRealPart());
System.out.println(c3.getImaginaryPart());
Complex c4 = new Complex(4, -0.5);
Complex[] list = { c1, c2, c3, c4 };
java.util.Arrays.sort(list);
System.out.println(java.util.Arrays.toString(list));
}
}

// BEGIN REVEL SUBMISSION
class Complex implements Cloneable, Comparable<Complex>{
private double re;
private double im;
//******************************

// Constructor 1
public Complex(double real, double imag) {
re = real;
im = imag;
}
  
// Constructor 2
public Complex(double real) {
re = real;
im = 0;
}

// Constructor 3
public Complex() {
re = 0;
im = 0;
}

public double abs() {
return Math.sqrt(re * re + im * im);
}

//**********************************
// get method for real part
public double getRealPart() {
return this.re;
}

// get method for imaginary part
public double getImaginaryPart() {
return this.im;
}

@Override
public String toString() {
if(im < 0) {
return re + " " + im + "i";
}
return re + " + " + im + "i";
}

public Complex add(Complex temp) {
Complex result = new Complex();
result.re = this.getRealPart() + temp.getRealPart();
result.im = this.getImaginaryPart() + temp.getImaginaryPart();
return result;
}

public Complex subtract(Complex temp) {
Complex result = new Complex();
result.re = this.getRealPart() - temp.getRealPart();
result.im = this.getImaginaryPart() - temp.getImaginaryPart();
return result;
}

public Complex multiply(Complex temp) {
Complex result = new Complex();
result.re = (this.getRealPart() * temp.getRealPart()) - (this.getImaginaryPart() * temp.getImaginaryPart());
result.im = (this.getRealPart() * temp.getImaginaryPart()) + (this.getImaginaryPart() * temp.getRealPart());
return result;
}

public Complex divide(Complex temp) {
Complex result = new Complex();
result.re = (((this.getRealPart() * temp.getRealPart()) + (this.getImaginaryPart() * temp.getImaginaryPart()))
/ (Math.pow(temp.getRealPart(), 2) + Math.pow(temp.getImaginaryPart(), 2)));
result.im = (((this.getRealPart() * temp.getImaginaryPart()) - (this.getImaginaryPart() * temp.getRealPart()))
/ (Math.pow(temp.getRealPart(), 2) + Math.pow(temp.getImaginaryPart(), 2)));
return result;
}

@Override
public int compareTo(Complex o) {
return (int) (abs() - o.abs());
}
  
public Object clone() {
return new Complex(getRealPart(), getImaginaryPart());
}
}

but I got the result:

Input for the Test 34 23 23 1.4 Your Output Enter the first complex number: 34.0 23.0 Enter the second complex number: 23.0 1.4 (34.0 + 23.0i) + (23.0 + 1.4i) = 57.0 + 24.4i (34.0 + 23.0i) - (23.0 + 1.4i) = 11.0 + 21.6i (34.0 + 23.0i) * (23.0 + 1.4i) = 749.8 + 576.6i (34.0 + 23.0i) / (23.0 + 1.4i) = 1.5334488473708001 -0.9066596353774294i 134.0 + 23.0il = 41.048751503547585 false 34.0 23.0 [4.0 -0.5i, 23.0 + 1.4i, 34.0 + 23.0i, 34.0 + 23.01] The Correct Output The correct output should contain the following substrings in this order, separated by the # sig ns. Note that the # sign is not part of the output. (34#+#23.0i )#+#(23.0#+#1.4i )#-#57.#+#24.4i#(34#+#23.0i)#-#(23.0#+#1.4i)#=#11. #+#21.6i#(34#*#23# i)#*#(23.6#+#1.4i )#=#749.8#+#576.6i#(34.#+#23#i )#/#(23#+#1.4i )#=#1.53344884#+#0.9066#i#134.#+#2 3.0i [#=#41.04875#false#34. #23 The hint for selected REVEL Programming Projects are available at https://liveexample.pearsoncm g.com/supplement/REVELProjectHint.pdf. Here is a correct sample run for this test: Enter the first complex number: 34.0 23.0 Enter the second complex number: 23.0 1.4

I would like to get + 0.9066596353774294i instead of -0.9066596353774294i.

Answer 1

<terminated > Exercise 13_17 [Java Application] C:\Program Files\Java\jdk1.8.0_251\bin\javaw.exe (Jul 27, 2020, 1: Enter the first complex number: 34 23 Enter the second complex number: 23 1.4 (34.0 + 23.0i) + (23.0 + 1.4i) = 57.0 + 24.4i (34.0 + 23.0i) - (23.0 + 1.4i) = 11.0 + 21.6i (34.0 + 23.0i) * (23.0 + 1.4i) = 749.8 + 576.6i (34.0 + 23.0i) / (23.0 + 1.4i) = 1.5334488473708001 + 0.9066596353774296i 34.0 + 23.0i| = 41.048751503547585 false 34.0 23.0 [4.0 -0.51, 23.0 + 1.4i, 34.0 + 23.0i, 34.0 + 23.0i] } هه 77 return re + " + " + im + "i"; 78 } 79 800 public Complex add(Complex temp) { 81 Complex result = new Complex(); 82 result.re = this.getRealPart() + temp-getRealPart(); 83 result.im = this.getImaginaryPart() + temp.getImaginaryPart(); 84 return result; 85 86 87 public Complex subtract(Complex temp) { 88 Complex result = new Complex(); 89 result.re = this.getRealPart() - temp.getRealPart(); 90 result.im = this.getImaginaryPart() - temp.getImaginaryPart(); 91 return result; 92 93 940 public Complex multiply(Complex temp) { 95 Complex result = new Complex(); 96 result.re = (this.getRealPart() temp.getRealPart()) - (this.ge 97 result.im = (this.getRealPart() * temp.getImaginaryPart()) + (th: 98 return result; 99 100 1012 private Complex reciprocal() { 102 double scale = re*re + im*im; 103 return new Complex(re / scale, -im / scale); 104 105 1060 public Complex divide (Complex temp) { 107 return this.multiply(temp.reciprocal()); 108 109 1100 @Override 111 public int compareTo(Complex o) { 112 return (int) (abs() - 0.abs()); 113 114 1150 public Object clone) { 116 return new Complex(getRealPart(), getImaginaryPart()); 117 118 } 119 // END REVEL SUBMISSION } بها } بها نہا

import java.util.Scanner;

public class Exercise13_17 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter the first complex number: ");
        double a = input.nextDouble();
        double b = input.nextDouble();
        Complex c1 = new Complex(a, b);

        System.out.print("Enter the second complex number: ");
        double c = input.nextDouble();
        double d = input.nextDouble();
        Complex c2 = new Complex(c, d);

        System.out.println("(" + c1 + ")" + " + " + "(" + c2 + ")" + " = " + c1.add(c2));
        System.out.println("(" + c1 + ")" + " - " + "(" + c2 + ")" + " = " + c1.subtract(c2));
        System.out.println("(" + c1 + ")" + " * " + "(" + c2 + ")" + " = " + c1.multiply(c2));
        System.out.println("(" + c1 + ")" + " / " + "(" + c2 + ")" + " = " + c1.divide(c2));
        System.out.println("|" + c1 + "| = " + c1.abs());

        Complex c3 = (Complex) c1.clone();
        System.out.println(c1 == c3);
        System.out.println(c3.getRealPart());
        System.out.println(c3.getImaginaryPart());
        Complex c4 = new Complex(4, -0.5);
        Complex[] list = { c1, c2, c3, c4 };
        java.util.Arrays.sort(list);
        System.out.println(java.util.Arrays.toString(list));
    }
}

// BEGIN REVEL SUBMISSION
class Complex implements Cloneable, Comparable<Complex>{
    private double re;
    private double im;
    //******************************  

    // Constructor 1
    public Complex(double real, double imag) {
        re = real;
        im = imag;
    }
    
    // Constructor 2
    public Complex(double real) {
        re = real;
        im = 0;
    }

    // Constructor 3
    public Complex() {
        re = 0;
        im = 0;
    }

    public double abs() {
        return Math.sqrt(re * re + im * im);
    }

    //**********************************
    // get method for real part
    public double getRealPart() {
        return this.re;
    }

    // get method for imaginary part
    public double getImaginaryPart() {
        return this.im;
    }

    @Override
    public String toString() {
        if(im < 0) {
            return re + " " + im + "i";
        }
        return re + " + " + im + "i";
    }

    public Complex add(Complex temp) {
        Complex result = new Complex();
        result.re = this.getRealPart() + temp.getRealPart();
        result.im = this.getImaginaryPart() + temp.getImaginaryPart();
        return result;
    }

    public Complex subtract(Complex temp) {
        Complex result = new Complex();
        result.re = this.getRealPart() - temp.getRealPart();
        result.im = this.getImaginaryPart() - temp.getImaginaryPart();
        return result;
    }

    public Complex multiply(Complex temp) {
        Complex result = new Complex();
        result.re = (this.getRealPart() * temp.getRealPart()) - (this.getImaginaryPart() * temp.getImaginaryPart());
        result.im = (this.getRealPart() * temp.getImaginaryPart()) + (this.getImaginaryPart() * temp.getRealPart());
        return result;
    }
    
    private Complex reciprocal() {
        double scale = re*re + im*im;
        return new Complex(re / scale, -im / scale);
    }

    public Complex divide(Complex temp) {
        return this.multiply(temp.reciprocal());
    }

    @Override
    public int compareTo(Complex o) {
        return (int) (abs() - o.abs());
    }
    
    public Object clone() {
        return new Complex(getRealPart(), getImaginaryPart());
    }
}
// END REVEL SUBMISSION

**************************************************

Thanks for your question. We try our best to help you with detailed answers, But in any case, if you need any modification or have a query/issue with respect to above answer, Please ask that in the comment section. We will surely try to address your query ASAP and resolve the issue.

Please consider providing a thumbs up to this question if it helps you. by Doing that, You will help other students, who are facing similar issue.