Lab 8: Trig, Complex Numbers, and the Mandelbrot Set
CS145: Images and Imagination, Fall 2010

Readings and Resources

• Online: Trigonometry
• Why Complex Numbers
• Wikipedia

Summary of Goals

The main goals of this lab are to:

• Learn about trigonometric functions.
• Practice using the map function.
• Learn about complex numbers and Object Oriented Class notation.
• Use the above to generate the Mandelbrot set.

Trigonometry Examples

• The Map Function: The map function is very useful when one wants to draw a picture which is a different scale from the window. For example, if you have created a shape whose coordinates are in the range of 1 to 2, yet you want to display it to fill a window of size 400 by 400. Read about the map function in the online Processing reference. You will need to use it in the Mandelbrot program.

• Trigonometry: In class, we will do a quick review of trigonometry. An overview is also given online. Open up Processing and paste in the code that is given at the bottom of this link. Run the program, paying close attention to how the animation relates to the sine function.

• Several very simple examples are shown below which illustrate the functions behavior. Try running them and changing the values of various parameters.

  Program 1: Trig Function Example #1 - Plot angle along x-axis.
  void setup() { size(400,400); strokeWeight(4); translate(0,height/2); colorMode(HSB,width,100,100); float amplitude = height/4.; float freq =3.; for (int x = 0; x < width; x++) { stroke(x,100,100); float angle = map(x,0,width, 0, freq*360); float y = amplitude*sin( radians(angle)); point(x, y); } }

  Program 2: Trig Function Example #2 - Plot in polar coordinates.
  void setup() { size(400,400); strokeWeight(4); colorMode(HSB,360,100,100); translate(width/2,height/2); float radius = height/3.; for (int angle = 0; angle < 360; angle++) { stroke(angle,100,100); float x = radius*cos(radians(angle)); float y = radius*sin(radians(angle)); point(x, y); } }

  Program 3: Trig Function Example #3 - Setting the color using the amplitude
  void setup() { size(400,400); strokeWeight(4); colorMode(HSB,width,100,100); float radius = height/3.; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float val = 1 + cos(radians(x))*sin(radians(y)); stroke(val*width/2.,100,100); point(x, y); } } }

  The program below is similar to Program 3 except that it allows of you to change the frequency interactively (press the 'a' or 's' key).

  Program 4: Trig Function Example #4 - Setting the color using the amplitude interactively

  float scale = 1; void setup() { size(400,400); colorMode(HSB,width,100,100); } void draw() { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float val = 1+ cos(radians(scale*x))*sin(radians(scale*y)); stroke(val*width/2.,100,100); point(x, y); } } } void keyPressed() { if (key=='a') scale += .1; else if (key=='s') scale -= .1; println("scale = " + scale); }

Complex Numbers

• Computing Complex Numbers by Hand: In class, we will go over the origin, definition, and operations of complex numbers. Once you are comfortable with the concepts, work through the following problems: Complex Number Problems (pdf).

  The solutions can be found here (pdf) but it is important that you try to do these without first looking at the solutions!

• Computing Complex Numbers by Computer - using Classes

  In class we will go over the notation for creating a complex number using the class defined below. Create a new Processing program, and copy Program 5 into it. Next, create a new tab (see Lab 3 if you forgot how to do this) and copy the code below given in Program 6 in this new tab. Some of the functions are not implemented. We will do these in class.

  To test your understanding of the notation, fill in the missing sections and then try to reproduce the results for problem 5 in the written exercises.

  Program 5: Setup for using the Complex Class

  void setup() { Complex c1 = new Complex(1,2); Complex c2 = new Complex(3,4); Complex m = Complex.cMult(c1,c2); println("c1 = " + c1 + " c2 = " + c2 + " c1*c2 = " + m); }

  Program 6: Complex Number Class

  // This class stores complex numbers. static class Complex { float real = 0; float imag= 0; Complex() { } Complex(Complex c) { real = c.real; imag = c.imag; } Complex (float r, float i) { real = r; imag = i; } static Complex conjugate(Complex c) { return new Complex(c.real, - c.imag); } static Complex cMult(Complex c1, Complex c2) { float realPart = 0; // NEED TO COMPLETE float imagPart = 0; // NEED TO COMPLETE return new Complex(realPart,imagPart); } static Complex sMult(float scalar, Complex c) { return new Complex(scalar*c.real,scalar*c.imag); } // Adds two complex numbers, c1 + c2 static Complex cAdd(Complex c1, Complex c2) { float realPart = 0; // NEED TO COMPLETE float imagPart = 0; // NEED TO COMPLETE return new Complex(realPart,imagPart); } // Subtracts two complex numbers, c1 - c2 static Complex cSub(Complex c1, Complex c2) { float realPart = c1.real - c2.real; float imagPart = c1.imag - c2.imag; return new Complex(realPart,imagPart); } // Divides two complex numbers, c1 / c2 static Complex cDiv(Complex c1, Complex c2) { float den = c2.zAbs(); Complex c = cMult(c1, conjugate(c2)); return sMult(1./den,c); } // convert polar coordinates to Cartesian coordinates. static Complex polar2Cart(float r, float degrees) { float realPart = 0; // NEED TO COMPLETE float imagPart = 0; // NEED TO COMPLETE return new Complex(realPart,imagPart); } static float len(Complex c) { return sqrt(c.real*c.real+ c.imag*c.imag); } static float angle(Complex c) { if (c.real==0 && c.imag == 0) return 0; else if (c.real >= 0) return asin( c.imag/len(c)); else return PI-asin(c.imag/len(c)); } // Computes z^n where n is assumed to be an integer static Complex pow(Complex c, int n) { if (n==0) return new Complex(1,0); Complex cn = new Complex(c); for (int i = 1; i < abs(n); i++) { cn = Complex.cMult(cn,c); } if (n < 0) cn = Complex.cDiv(new Complex(1,0),cn); return cn; } float zAbs() { return real*real + imag*imag; } String toString() { return real + " + " + imag + "i"; } }

The Mandelbrot Set

• The Mandelbrot Set: Below is the code for drawing the Mandelbrot Set. Some sections are missing. You also need to add the tab for the Complex Number class. We will go over in class what needs to be put in these sections. When completed, the code should give the image on the right.

  Program 7: The Mandelbrot Set

  void setup() { size(500,500); mandelbrot(); save("mandelbrot.png"); } void mandelbrot() { int max = 100; // max number of iterations // set the drawing region float minX = -2, maxX = 1; float minY = -1.5, maxY = 1.5; // loop over each pixel in window for (int i = 0; i < width; i++ ) { for (int j = 0; j < height; j++) { // Use map() to convert pixel (i,j) to a point c in the drawing region: float c_real = 0; // NEED TO COMPLETE float c_imag = 0; // NEED TO COMPLETE Complex c = new Complex(c_real,c_imag); Complex z = new Complex(0,0); // z starts at 0 int k; // must declare outside loop for (k = 0; k < max; k++) { z = 0; // NEED TO COMPLETE // compute z = z^2 + c // NEED TO COMPLETE // stop if length of z exceeds 2 } setColor(k,max); // here, k is the number of iterations point(i,j); // draw point in window } } } // Set the color based on the number of iterations void setColor(int k,int max) { // set the color based on k, max if (k < max) stroke(0) ; else stroke(255); }

• Changing the region: The region of the complex plane that is drawn is given by minX,maxX, minY, and maxY. You can change these to zoom into specific regions of the plane. Try changing these values.

• Setting the color: Remember that k varies from 0 to max=100. If the iteration converges (i.e. the length never exceeds 2), then we will have k=100. This corresponds to the white region. The black region corresponds to where the iteration blows up. The value of k is a measure of how fast it blows up (and so k will be less than 100). To get a range of colors in this region, modify the if-statement to include more values of k. For example, we can get three colors as follows:

  void setColor(int k,int max) { if (k< 6) stroke(255,0,255) ; else if (k < max) stroke(0,0,255); else stroke(255); }

  One can also use the final length of z to set the color. Experiment with changing colors and regions as was done here:

Further Explorations: Iterated Function Systems (not to be turned in)

• Barnsley Fern: Iterated function systems are another approach to using iteration to generate images. We will not go into the mathematical foundations for this, although it is based on a similar idea as for the Mandelbrot set, namely, iterating on some function. The Barnsley Fern is a well known example of this. Try running the code below.

  Program 8: The Barnsley Fern

  float x=0, y=0; void setup() { background(0); size(400,600); smooth(); stroke(0,255,0); for (int i = 0; i < 50000; i++) { iterate(); float xWindow = map(x, -3.3, 3.3, 0, width); float yWindow = map(y, 0, 10, height,0); point(xWindow,yWindow); } } void iterate() { int r = (int) random(1000); if (r<850) { x = 0.85*x + 0.04*y; y = -0.04*x + 0.85*y + 1.6; } else if (r<920) { x = -0.15*x + 0.28*y; y = 0.26*x + 0.24*y + .44; } else if (r<990) { x = 0.2*x + -0.26*y; y = 0.23*x + 0.22*y + 1.6; } else if (r<=1000) { x = 0; y = 0.16*y; } else { println("out of range r = " + r); } }

• One can use an array to keep track of how many times the iteration lands on a given pixel. This count can then be used to set the stroke color. The result is shown below as the number of iterations is increased.

• Another example of an iterated function system is shown below. It iterates on complex numbers. Copy the program below into a Processing sketch. You will need to add a new tab for the complex number class from above (Program 6).

  Program 9: Iterated Function System using Complex Numbers

  Complex z = new Complex(.1,.21); int pixels[][]; void setup() { background(0); size(300,300); smooth(); colorMode(HSB, 100); pixels = new int[width][height]; getStarted(); drawMe(); } // We don't save these values void getStarted() { for (int i=0; i < 1000; i++) { z = f(z,4,-1.86,2.0,0,1,.1); // Z4 symmetry } } // We do save these values void drawMe() { for (int i=0; i < 500000; i++) { z = f(z,4,-1.86,2.0,0,1,.1); // Z4 symmetry put(z.real, z.imag); } } // Draw the point and increase the count at that pixel. void put(float real, float imag) { int xval = (int) map(real,-1, 1, 0, width); int yval = (int) map(imag,-1, 1, 0, height); pixels[xval][yval]++; stroke((3*pixels[xval][yval]) % 100,100,100); point(xval,yval); // plot point in window } // This computes the function: // f(z) = ( lambda + alpha*z*z_bar + beta*Re(z^n) + omega i )*z + gamma * z_bar^(n-1) // where z_bar is the complex conjugate of z // See book: Symmetry in Chaos, Field and Golubitsky Complex f(Complex z, int n, float lambda, float alph, float beta, float gamma, float omega) { Complex ans = new Complex(lambda,0); ans = Complex.cAdd(ans, Complex.sMult(alph, Complex.cMult(z, Complex.conjugate(z)))); // lamda + alph*z*z_bar ans = Complex.cAdd(ans, new Complex(beta*(Complex.pow(z,n).real), omega)); // + beta Re(z^n) + omega i ans = Complex.cAdd( Complex.cMult(ans, z),Complex.sMult(gamma, Complex.pow(Complex.conjugate(z),n-1))); // z*ans + gamma* z_bar^(n-1) return ans; }

  Below are sample images as the number of iterations is increased.

To Be Submitted

As in previous labs, zip together your entire sketch folder containing a single Mandelbrot sketch containing multiple setColor functions for setting the color. Include in the folder at least 4 different images (e.g. png files) that you obtained by varying the region and the color function. Add the zip file as an attachment in WISE. Please don't forget to follow the steps below for cleaning up your code. Clean, well commented, and easy to understand code is very important.

Follow the directions from previous labs for preparing the files for submitting to WISE.

By 9am of Tuesday, Nov 30, submit the single zipped file via WISE as an attachment.