## Description

A. (100 points) Mandelbrot Fractals

This examination consists of designing and writing a single well-structured Python program that must be

committed and pushed to your remote GitHub examination repository prior to the deadline.

Late submissions will not be accepted and will result in a zero score for the exam.

TA help for this examination will not be provided. If you have clarification questions, they must be addressed

to the graduate TA for the class.

The total point value will be awarded for solutions that are complete, correct, and well structured. A “well

structured” program entails good design that employs meaningful functional decomposition, appropriate

comments and general readability (descriptive names for variables and procedures, appropriate use of blank

space, etc.) If you are not sure what this means, review the “well-structured” program requirements provided in

Lab2.

Note that your work will be graded using, and must function correctly with, the current version of Python 3 on

CSE Labs UNIX machines. If you complete this programming exam using a different system, it is your

responsibility to ensure it works on CSELabs machines prior to submitting it.

The rubric includes the following specific (accumulative) point deductions:

• Missing academic integrity pledge -100 points

• Syntax errors -50 to -100 points

• Misnamed source file or incorrect repository -25 points

• Use of global variables -25 points

• Missing main program function -25 points

Examination Repository

Examination files must be submitted to GitHub using your remote exam repository. Exam repositories have

already been created for each registered student and are named using the string exam- followed by your X500

userID (e.g., exam-smit1234). You must first clone your exam repository in your local home directory

before submitting the materials for this exam. If you are having difficulty, consult the second Lab from earlier

in the semester or the GitHub tutorial on the class webpage. If your exam repository is missing or something is

amiss, please contact the graduate TA. DO NOT SUBMIT YOUR EXAM FILES TO YOUR LAB/EXERCISE

REPOSITORY!

Introduction

For this project, you will employ basic Object Oriented Programming techniques to construct a program that

displays a Mandlebrot fractal image using Turtle graphics. The program will allow the user to “click” anywhere

on the fractal image to “zoom-in”, demonstrating the self-similarity of complex fractals. The program will

consist of three separate classes that interact to construct and display a Mandelbrot fractal.

Background

Fractals are mathematical sequences that are “made of parts similar to the whole in some way”. When we

graph the values of complex fractal sequences on an x,y Cartesian plane, they often produce stunning visual

images. Check out the following Wikipedia description:

https://en.wikipedia.org/wiki/Fractal

Enlarging (“zooming-in”) on fractal images will often reveal “self-similar” patterns, i.e., small patterns that look

exactly like the original.

One famous fractal image is derived from the so-called Mandelbrot set which is based on a curious property

exhibited by Mandelbrot sequences. A Mandelbrot sequence is constructed by starting with an arbitrary

complex number, C0. Each subsequent value of the sequence is computed from its predecessors according to the

following equation:

Z0 = C0

Zn+1 = (Zn)

2 + Z0

For an arbitrary complex number C0, the Mandelbrot sequence is an infinite series in which the first value is C0,

the next value is C0 added to the square of the previous value in the sequence, and so on.

The values in most Mandelbrot sequences will grow infinitely. However there is a special subset of the starting

values, C0 that result in Mandelbrot sequences that remain bounded within a finite region! The collection of all

such starting values, C0, is referred to as the Mandelbrot set. The sequences formed from the starting values in

the Mandelbrot set are all bounded by a finite region in the complex plane and only contain complex numbers

whose absolute values less than 2.

When plotted on an x,y Cartesian plane, the Mandelbrot set produces stunning fractal patterns such as this one

(from wikipedia.org):

Drawing Mandelbrot Fractals

We can visualize the Mandelbrot set by graphing it on the complex plane instead of the real plane. Throughout

the semester we’ve been using Turtle graphics to graph numbers in the real plane. If we passed two real

numbers to turtle.goto(x, y) the turtle would go the position x on the x-axis and the position y on the

y-axis. The complex plane is similar to the real plane, however we no longer think in terms of x and y axes.

Instead, we will let the horizontal axis correspond to the real part of a complex number and the vertical axis

correspond to the imaginary part of a complex number.

In this way, we can match each of the x,y turtle coordinates on a screen to an equivalent point on the complex

plane and then test each complex point for membership in the Mandelbrot sequence. If the complex point

represents a starting value, C0 for a Mandelbrot sequence that always produces a number whose absolute value

is <= 2, then the point is a member of the Mandelbrot set and colored black. If you attempt to compute the
Mandelbrot sequence and you encounter a complex number with an absolute value greater than two, then you
color that point white.
Note that we cannot compute an entire (infinite) Mandelbrot sequence, because we cannot run our computers
for an infinite amount of time! Instead, when drawing fractals we compute the Mandelbrot sequence up to a
finite limit (50 iterations will be a good approximation for this project). If the Mandelbrot sequence for a given
value of C0 goes out of bounds (absolute value >2) before this limit is reached, then C0 is not a member of the

set. If all of the values up to Zlimit have absolute values <= 2, then we will assume that C0 is a member of the
Mandelbrot set.
We now have all of the pieces to plot a Mandelbrot set in black and white. We visit each x,y coordinate on the
turtle canvas, translate that coordinate into a coordinate on the complex plane, then use that complex number as
the starting value to compute a Mandelbrot sequence until we reach the iteration limit. At that point, if the
complex coordinate is still in the Mandelbrot set we could color it black. If we found that the coordinate was
not in the Mandelbrot set, we could color that coordinate white.
Adding color
Black and white fractals are nice, but it's even more interesting to plot a color representing the proximity of a
complex point to the Mandelbrot set. Since the Mandelbrot sequence is a sum of squares, a point that quickly
generates an out-of-bounds complex number should be colored differently than a point that generates an out-ofbounds value on the last iteration.
Because color is not an intrinsic part of the Mandelbrot set, there are many ways we could color our image. One
way is to create a list of some fun colors and indicate how close a point is to membership in the Mandelbrot set
by choosing a color based on the index of the first term in the sequence whose absolute value is > 2.

Part 1: Complex Number Class

In order to create a Mandelbrot sequence, we must be able to represent complex values and compute complex

expressions. Although Python provides a built-in numeric type: complex that supports operations on complex

numbers, assume that such a class does not exist and create your own user-defined complex number class to use

in Part 2. Note that a complex number is of the form a + bi where a and b are real numbers and i

2 = -1. For

example, 2.4 + 5.2i and 5.73 – 6.9i are complex numbers. Here, a is called the real part of the complex number

and bi the imaginary part. For more information on complex numbers refer to the Wikipedia page:

https://en.wikipedia.org/wiki/Complex_number

Create and (thoroughly test!) a class named Complex to represent complex numbers. Save your class

definition in a module named complex.py. The members of this class are as follows:

Instance variables:

• Private real and imag of type float to represent the complex number real + imag i

Methods:

• A constructor that will initialize real and imag from user supplied arguments (default to zero)

• An overloaded __repr__ method that will return the complex value as a string in this form, e.g.:

2.3 + 4.6i

Note that if the imaginary component is zero, omit the “+ xi” part (i.e., display the number as a noncomplex “float”, and if the imaginary component is negative, replace the ‘+’ with ‘-‘.

• Accessor and mutator methods for both instance variables

• An overloaded __add__ (addition) operator that will return the sum of two Complex objects. For

complex numbers a + bi and c + di, addition is defined as: (a+c) + (b+d)i.

• An overloaded __mul__ (multiplication) operator that will return the product of two Complex

objects. Note that the product of 2 complex numbers is determined using distributed multiplication

(as in multiplying two polynomials):

(2 + 3i) • (4 + 5i) = 2(4 + 5i) + 3i(4 + 5i)

= 8 + 10i + 12i + 15i

2

= 8 + 22i + 15(-1)

= -7 + 22i

• An overloaded __abs__ (absolute value) operation that will return the absolute value of a complex

number. Note that the absolute value is the distance from the origin of the complex plane (0 + 0i )

to the complex number (HINT: “pythagoras”).

Part 2: Mandelbrot Sequence Class

After you have your complex number class working (and tested!), construct a separate class to represent

Mandelbrot sequences. The class name is Mandelbrot and should contain the following members:

Instance variables:

• Private limit (type int) that represents the maximum length Mandelbrot sequence

• Private colormap, a list of strings containing the Turtle color values used to color each point

• Private cardinality (type int) that indicates the number of consecutive complex values in the

computed sequence (starting from 0) whose absolute value is “in bounds” (i.e., <= 2)
Methods:
• A constructor that will take two arguments: the starting value, C0 for the Mandelbrot sequence (type
Complex) and the maximum length sequence to be computed (type int, defaults to 50). The
constructor should compute the Mandelbrot sequence for the given starting value and initialize the
instance variables.
• An accessor method named get_color that will return a color from the color map corresponding
to the cardinality of the set. Lower cardinality values (further from the Mandelbrot set) will
correspond with colors earlier in the list. A cardinality value equal to the maximum (limit)
should correspond to the color 'black'.
Part 3: Graphical Display Class
After you have your Mandelbrot class working (and tested!), construct a third separate class named
Display to handle the graphical display details. The Display class should instantiate a turtle object and
handle on-click operations. Your class must include the following:
• A constructor method that takes no arguments and handles hiding the turtle, setting the turtle speed to
zero, changing the `tracer` so that the program can draw more quickly, setting up the on-click action,
and drawing the first Mandelbrot fractal at the default zoom. The default zoom should draw the
complex point -2 - 2i in the bottom left corner, and the complex point 2 + 2i in the top right corner.
You need to include instance variables to keep track of the bounds of the visible part of the
Mandelbrot set and subsequently update them as the fractal is zoomed.
• A mutator method named click: that is called whenever the user clicks on the screen. (On-click
actions are described in more detail in the Python 3 Turtle documentation). Note: if a Mandelbrot set
is currently being drawn, or if the x,y coordinates are outside the fractal image, this method should do
nothing. If the turtle is not currently drawing the Mandelbrot set, the zoom operation should be
performed and the fractal redrawn.
• A mutator method named zoom that modifies the complex plane coordinates. This method should
modify the complex plane coordinates and redraw the Mandelbrot set so that it is magnified 2x and recentered around the point the user clicked. This will halve the width and height of the viewable section
of the Mandelbrot set. In order to accomplish this you should determine which point in the complex
plane was clicked, then recalculate the boundaries of the viewable section of the plane by making that
point the center of the new grid and making the new width and height of the grid half of the old width
and height.
• A mutator method named draw that will re-draw the Mandelbrot fractal at the current resolution. This
method should visit each x, y coordinate on the turtle canvas, translate that coordinate onto the
(zoomed) section of the complex plane, and color it according to how close it is to membership in the
Mandelbrot set (see suggestion 1 below). Note that computing membership in the Mandelbrot set for
each pixel on the canvas can significantly slow down your computer. Limiting the length of the
sequence to 50 iterations will speed it up, but in order to draw your fractal as quickly as possible, it is
recommended that you do NOT accomplish the drawing using the .dot or .stamp methods.
Instead, color each pixel (x, y) by putting the pen down, changing the pen to use the appropriate color,
and moving the turtle to a pixel close by (e.g., x, y + 1), which will paint the canvas with
approximately one pixel worth of color.
General Program Requirements
Using Turtle graphics, write a well-structured Python program that will display the fractal Mandelbrot set.
Your program will consist of 3 class definitions as described and a single main() function. The main function
simply needs to instantiate a single Display object to display the interactive graphics.
Your program must do the following:
• Include the academic integrity pledge in the program source code (details below)
• Use turtle graphics to implement the graphical interface (set the turtle speed to 0 in order to speed
things up, and set the pensize to 1 for maximum resolution).
• Your program should have a main function as described in class. Running your program from the
command line should automatically draw the Mandelbrot set at the default zoom and set up the screen
to accept user clicks. Note that the main function simply needs to instantiate a Display object.
Submission
Your Complex and Mandelbrot classes should each reside in separate modules named complex.py and
mandelbrot.py respectively. Your main program should include a main() function and reside in a
module named fractal.py that includes your Display class. Commit and push all three modules to your
exam repository. Please be sure to observe the naming requirements.
Constraints:
• You may use any built-in Python object class methods (string, list, etc.) except the built-in complex
number class
• You may use imported functions and class methods from the turtle module only.
• Do not use the .setworldcoordinates turtle method. Use the default (cartesian) settings for the
turtle screen (0,0 at the center of the window)
Academic Integrity Pledge
The first lines of your program must contain the following text (exactly as it appears below), replacing the first
line with your full name and X500 ID. If this statement does not appear in your program source, you will
receive a score of zero for the exam:
Suggestions:
1) We suggest that you provide the image size (in turtle "units") to the Display class constructor as an
argument. In this way, you can debug things at a smaller size and then use a larger (higher resolution) to
display the fractal when thing are working.
2) Make sure to set the turtle speed to 0, pensize to 1, and hide the turtle. You will also need to use the
.tracer method to speed things up. .tracer(2000,0) seems to work reasonably well, but you can
experiment with the value.
3) The process of plotting employs a nested loop that systematically moves (use the .goto method) the turtle
to every x,y turtle coordinate of the display. As the turtle moves with the pen down, it will draw a small (1 or 2
pixel) line in the color specified by the colormap for the Mandelbrot sequence. Note that the turtle must be
moved in x,y turtle coordinates, but the Mandelbrot sequence for each x,y location must be computed in
complex number plane coordinates. This requires a conversion from turtle coordinates (x,y) to complex plane
coordinates (real, imaginary).
Consider the example figure below for a 300 by 300 pixel turtle window. The center coordinates of the window
are 0,0 which correspond to 0+0i in the complex plane (for the initial display). The lower leftmost pixel is at -
150, -150 which corresponds to the -2-2i in the complex plane.
The conversion is straightforward based on the following scale relationship (a similar relationship holds for the
vertical axis):
x / (xmax - xmin) = real / (realmax-realmin)
Note that after a "zoom" operation, the x,y plane will remain unchanged, however the complex plane will be
rescaled and the origin will be offset from 0,0 relative to the image!
Example Program Output: