By writing \(z=x+\I {}y\) and \(c=c_x+\I {}c_y\), the expression \(z^2+c\) can be expanded as follows:
\(\seteqnumber{0}{C.}{0}\)
\begin{align*}
z^2+c &= (x + \I {}y)^2 + (c_x + \I {}c_y)\\ &= x^2 - y ^2 + 2\I {}xy + c_x + \I {}c_y\\ &= (x^2 - y ^2 + c_x) + \I {}(2xy +c_y)
\end{align*}
The second step uses the identity \(\I ^2=-1\).
Solution to Exercise 2.3
A black-and-white image of the Mandelbrot set can be created by constructing a color palette that is completely white, except for the last color, which is set to black. The two grayscale palettes can be initialized as follows:
for (int i = 0; i < colors.length; i++) {
float g = 1 - i / (float) (colors.length - 1);
colors[i] = new Color(g, g, g).getRGB();
}
The two resulting grayscale images are shown in Fig. C.3.
Figure C.3 Two grayscale renditions of the Mandelbrot set.
Solution to Exercise 2.4
To compute the Nebulabrot shown in Fig. C.4, we first compute three histograms by calling Buddhabrot.
computeHistogram() with different iteration limits. We then combine these histograms by mapping them to separate color channels, as shown in Listing C.8.
Figure C.4 The Nebulabrot is obtained by writing three different renderings of the Buddhabrot to the red, green, and blue channels of a raster image.
Listing C.8ch2β―/β―Buddhabrot
public static void drawNebulabrot(
int numTrajectories, BufferedImage image) {
var bb = new Buddhabrot(image.getWidth(), image.getHeight());
int[][] histoR = bb.computeHistogram(numTrajectories, 5000);
int[][] histoG = bb.computeHistogram(numTrajectories, 500);
int[][] histoB = bb.computeHistogram(numTrajectories, 50);
float maxR = 0.3f * maximum(histoR);
float maxG = 0.3f * maximum(histoG);
float maxB = 0.3f * maximum(histoB);
for (int y = 0; y < image.getHeight(); y++) {
for (int x = 0; x < image.getWidth(); x++) {
float r = Math.min(histoR[y][x] / maxR, 1.0f);
float g = Math.min(histoG[y][x] / maxG, 1.0f);
float b = Math.min(histoB[y][x] / maxB, 1.0f);
image.setRGB(x, image.getHeight() - 1 - y,
new Color(r, g, b).getRGB());
}
}
}
a)The escapeTime() method in Listing C.9 computes the escape time of the Mandelbrot
iteration. In contrast to our previous implementation, this function takes not just the parameter \(c\) but also the starting point \(z_0\) as arguments. We can use this escapeTime() method to render the Julia set as follows:
for (int y = 0; y < image.getHeight(); y++) {
for (int x = 0; x < image.getWidth(); x++) {
double x0 = xMin + x * pixelSize;
double y0 = yMin + y * pixelSize;
image.setRGB(x, image.getHeight() - 1 - y,
colors[JuliaSet.escapeTime(cx, cy, x0, y0,
maxIterations)]);
}
}
For Julia sets we keep the parameter \(c\) constant and vary the starting point \(z_0\).
Listing C.9ch2β―/β―JuliaSet
// Compute the escape time for the Julia set.
public static int escapeTime(double cx, double cy,
double x0, double y0, int maxIterations) {
double escapeRadius = 2.0;
double xn = x0, yn = y0;
for (int k = 0; k < maxIterations; k++) {
if (xn * xn + yn * yn > escapeRadius * escapeRadius)
return k;
double x = xn, y = yn;
xn = x * x - y * y + cx;
yn = 2 * x * y + cy;
}
return maxIterations;
}
Solution to Exercise 2.6
a)Listing C.10 shows an implementation of the Game of Life. To store the state of all cells, we define two arrays of Boolean values, one for the current generation (grid) and one for the next (next). The size of
both arrays is \(\mathtt {height}\times \mathtt {width}\).
Listing C.10ch2β―/β―GameOfLife
public class GameOfLife {
public final int width, height;
private boolean[][] grid, next;
public GameOfLife(int width, int height) {
this.width = width;
this.height = height;
this.grid = new boolean[height][width];
this.next = new boolean[height][width];
}
public void set(int x, int y, boolean value) {
int row = Math.floorMod(y, height);
int col = Math.floorMod(x, width);
grid[row][col] = value;
}
public int get(int x, int y) {
int row = Math.floorMod(y, height);
int col = Math.floorMod(x, width);
return grid[row][col] ? 1 : 0;
}
public void advance() {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int n = get(x - 1, y - 1) + get(x, y - 1)
+ get(x + 1, y - 1) + get(x - 1, y)
+ get(x + 1, y) + get(x - 1, y + 1)
+ get(x, y + 1) + get(x + 1, y + 1);
next[y][x] =
get(x, y) == 1 ? (n == 2 || n == 3) : n == 3;
}
}
var tmp = grid;
grid = next;
next = tmp;
}
}
The get() and set() methods read and change the state of individual cells. We translate
coordinates \((x,y)\) on the infinite grid to the finite domain of size \(\mathtt {width}\times {}\mathtt {height}\) using the modulo operator:
\(\seteqnumber{0}{C.}{0}\)
\begin{align*}
x' = x\bmod \mathtt {width},\qquad y' = y\bmod \mathtt {height}.
\end{align*}
We use the floorMod() function to implement these formulas, which is similar to the % operator but always returns a nonnegative number.
The advance() method computes the next game state from the current one by updating every cell. The function counts for each grid point how many of its eight neighbors are alive and sets the
corresponding cell in next to either empty or alive. To make it appear as if all cells were updated at once, the code uses two separate arrays: grid holds the current cells and next the cells of the next generation. After computing the next state, the two arrays are
swapped: next becomes current state, and grid is recycled and used to hold the new state in the next round.
b)The R-pentomino grows and evolves over hundreds of generations before it finally settles in a stable configuration. The LWSS moves horizontally and advances by \(2\) cells every \(4\) cycles. The abbreviation LWSS stands for lightweight spaceship; it is another example of
a spaceship.
c)The following table summarizes the behavior of life forms that consists of \(n\) cells in a row:
.
\(n\)
Behavior
1, 2
disappears after 1 generation
3
oscillates
4
stable after 2 generations
5
oscillates after 6 generations
6
disappears after 12 generations
7
stable after 14 generations
8
stable after 48 generations
9
oscillates after 20 generations
10
oscillates after 2 generations
d)The life form in Fig. 2.8 “inverts” the stream of gliders that moves toward the bottom left. If we write the incoming stream of gliders as “111010000…”, the outgoing stream of gliders is “000101111…”, the
inverse of the input.
