CSE1030Z Lab 03

Introduction

The purpose of this lab is to implement an immutable class, which includes adding documentation in the form of Javadoc comments and generating APIs using the Javadoc tool, as well as testing against a set of unit tests. This lab will be graded for style and correctness.

There is one question to this lab. You need to submit your solution by the end of the lab session.

Question 1: Complex Numbers

Complex numbers arise when you try to compute a root of a negative number. For example, the square root of -1 is not a real number; however, mathematicians have found that it is very useful to say that there exists some number (not real) that is the square root of -1. Historically, such a number was called "fictitious" or "imaginary", and is now written as the symbol i. $$\sqrt{-1}=i$$

A complex number is a number that can be written as $$a+bi$$ where $a$ and $b$ are real numbers. The $a$ is called the real part of the complex number, and the $b$ is called the imaginary part of the complex number.

Complex numbers turn out to be very useful in mathematics (complex analysis, for example), physics (in the study of waves, electromagnetism, and quantum mechanics, for example), the study of signals (signal and image processing, for example), ...

Here are some elementary operations that you can do with complex numbers:

Operation	Definition	Example
addition	$\left(a+bi\right)+\left(c+di\right)=\left(a+c\right)+\left(b+d\right)i$	$\left(3+3i\right)+\left(5-5i\right)=8-2i$
multiplication	$\left(a+bi\right)\times \left(c+di\right)=\left(ac-bd\right)+\left(bc+ad\right)i$	$\left(1+3i\right)\times \left(2+2i\right)=\left(1·2-3·2\right)+\left(3·2+1·2\right)i=-4+8i$
magnitude	$\left|\left(a+bi\right)\right|=\sqrt{a^2+b^2}$	$\left|\left(1+2i\right)\right|=\sqrt{1^2+2^2}=\sqrt{5}$

Implement a class named Complex in the package cse1030 that represents immutable complex numbers. Your class must provide the API shown here.

• Your class needs two private final attributes of type double to store the real and imaginary parts.
• Try to use constructor chaining to implement 3 of the 4 required constructors.
• Eclipse will generate acceptable versions of hashCode and equals
• Your class should include the necessary Javadoc comments to reproduce the API.
• If you cannot complete one or more of the methods, at least make sure that it returns some value of the correct type; this will allow the tester to run, and it will make it much easier to evaluate your code. For example, if you are having difficulty with valueOf then make sure that the method returns a Complex number created using the default constructor.

A JUnit tester for your class is available here. Instructions for using JUnit in Eclipse are here. Instructions for using JUnit from the command line are here. Note that the tester is not very thorough, and it may not catch all errors that you might make. Also note that passing all of the tests in this tester does not guarantee a good solution (in other words, you should think critically about your implementation for each method).

Perhaps the most widely seen visualization based on complex numbers is the Mandelbrot set. Once you have implemented and tested the Complex class, you can run this Java program that computes and draws a Mandelbrot set. You need to add the jar file

/cse/dept/www/course/classpath/1030Z/princeton_introcs.jar

to your project in Eclipse to run this program; if you are compiling from the command line then the jar file is already in your classpath. You should get the following output:

Submit your work using the following command in the directory where your Complex.java file is saved.

submit 1030Z L3R Complex.java

Note: valueOf is probably the most challenging method to implement in this lab. If you found it easy to implement, then consider implementing a version of valueOf that is insensitive to the number of spaces surrounding the sign separating the real and imaginary parts; your method should be able to produce complex numbers even where there are no spaces surrounding the sign. This is harder than it sounds...