Objective:

Assignment:

• Write a java program that generates the Mandelbrot set. You will implement Complex numbers as a class, with its own set of methods.

  The Mandelbrot set studies whether points on the complex plane tend toward infinity or not under repeated quadratic operations. Your program will output an image representing a region of the complex plane, showing how many times the quadratic operation was repeated against each point until the operation "reached infinity". Your program must adhere to the following specifications:

• Input to your program will consist of:
  • x-dimension and y-dimension, both integer values, indicating the size of the image to be generated.
  • left, right, bottom, top all floating point numbers, indicating the boundaries on the complex plane on which to generate the Mandelbrot set.
• Output of your program will be a PGM format image. Rather than writing to a file, write the image to standard output using System.out.print().
• Complex Class. Your program will implement Constructors and methods to operate on complex numbers. Your "main" class will be called Mandlebrot, but it will be saying things like Complex plexi = new Complex(); and plexi.setValue(2.62, -.01205); The Complex class is not in the Java standard library; it was not written by James Gosling, Ira Pohl or Charlie Mcdowell, you have to write it yourself. Make sure that the methods you define have the signatures that are specified here, because the grading program will call the methods of your complex class, and you could lose points on your methods even if the output of your program is correct.
  • public void setValue(double realComponenet, double imaginaryComponent){...}
    This method takes two doubles and assigns them to the real and imaginary components of the complex number object, IN THAT ORDER. No values are returned.
  • public Complex add(Complex c2){...}
    The add method takes a complex number, and returns a complex number that is the sum of itself and the parameter.
  • public Complex multiply(Complex c2){...}
    The multiply method takes a complex number, and returns a complex number that is the product of itself and the parameter.
  • public double modulusSquare(){...}
    The modulusSquare method returns the square of the Complex number's distance from the origin. The method does not take any parameters. Be careful: this method should not return the distance, it should return the square of the distance. Daniel L. got that wrong the first time he wrote the program, and was corrected by Michael Watts.
• Algorithm. The program must iterate over each pixel in the image and compute a color based on the Mandlebrot set. This computation involves two major steps.
• Mapping. Each pixel from image[0][0] to image[ydim][xdim] is mapped to a point in the complex plane within the region defined by left, right, bottom, top. Hence, the first pixel you process, image[0][0], should be mapped to left + top * i (recall that i is the square root of -1). Then, along the x dimension, we increase the real components of the complex numbers by dx; and along the y dimension, we decrease the imaginary components of the complex numbers by dy:

  dx = ( right - left ) / (xdim - 1)
  dy = ( top - bottom ) / (ydim - 1)
  

  This first step gives us a complex number to pass to the Mandlebrot recurrence equation. It could be implemented as a method
  static Complex mapToComplexPlane(int i, int j){...}
  but that is not a requirement.
• Counting. (Assume, for the puropese of this assignment that Rmax = a big number = 100 and MaxColor = the maximum color value = 255.) Once we have our complex number, we can plug it in to the Mandlebrot function. And then we can plug it in again. In fact, we need to run the Mandlebrot function repeatedly until the output of the function is sufficiently far from the origin. (For the purposes of our program, a Complex number z is "sufficiently far" when z.modulusSquare() > Rmax.) The Mandlebrot function is defined as:

  z(n+1) = z(n)*z(n) + c
  

  where z and c are complex numbers and c is a the point from the pixel array that you mapped to the complex region, z(n) is the output of the function from the last iteration, z(n+1) is the z(n) input to the function in the next iteration, and n keeps track of the number of iterations. When z gets far enough from the origin, that is, when z.modulusSquare() > Rmax, you color the pixel with the value n. If n reaches MaxColor (that is, 255) and you're not getting anywhere, color the pixel 0. You will conclude that a complex number tends to infinity if its modulusSquare exceeds Rmax.

  There are 3 possible outcomes in each iteration:

  • The modulusSquare of z(n+1) <= Rmax and n < MaxColor. If so, continue to iterate.
  • The modulusSquare of z(n+1) > Rmax. This means Mandlebrot went to infinity, in which case you will assign n to that point; then process the next point in the region of interest.
  • n equals MaxColor. This indicates that you have iterated MaxColor times already and Mandlebrot has not gone to infinity. In this case, you assign the value 0 to that location; then process the next point in the region of interest. This second step could be implemented as a method:
    static int countMandlebrots(Complex c){...}
    The Mandlebrot function itself could be implemented as a method:
    static Complex getZOfNPlusOne(Complex zOfN, Complex c){...}
    but that is not a requirement.
• Mandlebrot. After every point within the region of interest is processed, each point will have a value of 0 .. MaxColor. 0 means the point did not go to infinity after MaxColor iterations. Any other value between 1 .. MaxColor indicates the number of iterations against that point before Mandlebrot went to infinity (i.e. modulusSquare exceeded Rmax).

  That's the Mandelbrot set!

• Image. The output of your program is an image in PGM format. Recall that the PGM format is:
  

  P2 xdim ydim 255
  c11 c12 c13 ... c1xdim
  c21 c22 c23 ... c2xdim
  ...
  cydim1 cydim2 ... cydimxdim
  

  where 255 represents the maximum greyscale value;
  cij represents a greyscale value between 0 and 255.

• You can test drive the Mandelbrot program written by Daniel Libicki, by saving the Mandelbrot class file and the Complex class file running it.
• In terms of grading this program, your output must MATCH OUR OUTPUT EXACTLY! We will be using a grading program to see if there's any difference between your output and ours see the grading guide for more details . The sample session below shows you the corresponding PGM output file for a set of input parameters.

Sample Sessions:

• Please enter x and y dimensions:
  160 120
  Please enter left, right, bottom, top:
  -0.74758 -0.74624 0.10671 0.10779
  

  
  view output (160x120) view output (40x30) view output (4x3)

• Please enter x and y dimensions:
  160 120
  Please enter left, right, bottom, top:
  -1.254024 -1.252861 0.046252 0.047125
  

  
  view output (160x120) view output (40x30) view output (4x3)

• Other Images:

  Try the following coordinates, and experiment with your own too!

  Left	Right	Bottom	Top
  -2.25	0.75	-1.5	1.5
  -0.19920	-0.12954	1.0148	1.06707
  -0.95	-0.88333	0.23333	0.3
  -0.713	-0.4082	0.49216	0.71429
  -1.781	-1.764	0.0	0.013
  -0.75104	-0.7408	0.10511	0.11536
  -0.746541	-0.746378	0.107574	0.0107678
  -0.74591	-0.74448	0.11196	0.11339
  -0.745538	-0.745054	0.112881	0.113236
  -0.745468	-0.745385	0.112979	0.113039
  -0.7454356	-0.7454215	0.1130037	0.1130139
  -0.7454301	-0.7454289	0.1130076	0.1130085

Reminder!!!

All the work submitted here should be based on your own (or the pair's) effort. Plagiarism of other's works e.g. those found on the web, is considered cheating.

Submission:

• Important requirement: name your
  a. java file Mandelbrot.java and your
  b. class Mandelbrot
  This will greatly help us speed up the grading of your programs.

  DO NOT SUBMIT OUTPUT FILES, or we may run out of disk space for program submission.

  Remember to compile and test your program to make sure things compile and execute correctly on the unix.ic machines.

  Log into unix.ic.ucsc.edu and submit the source code (i.e. Mandelbrot.java) using the command:

          submit cmps012a-ap.w05 prog5 Mandelbrot.java
  

  You can submit more than once, for example to update your previous submission with new/improved code.
  However, each pair should designate 1 account to be used for doing submissions.

  Each person should separately submit a log file for each programming assignment.

Note:

Refer to the programming guide link for specifics on requirements and grading guide.

Notes on Color:

You can change your output into a color image using the xv program on the suns. You don't need to change anything in your program. Select the Windows button, then select color editor. On the color editor popup window, click on the random button. Each time you change the color map, your image will have a new set of colors!

On windows, you can do something similar. First, convert the pgm image into a gif or jpg image using some image conversion utility such as Imagemagick . View the image file using photoshop. Under the Image tab, first select mode and change to indexed color. Under the Image tab again, select mode again, and this time select color table. There are several predefined color tables you can pick from to alter the colormap of your image.

Color versions of session 1.

Color versions of session 2.