*t*depends on the state of the grid at time

*t-1*and it is determined with a very simple rule:

*A cell is alive if it's already alive and has two living neighbours, or if it has three live neighbours*.

We call the grid

*universe*and the alive cells

*population*. At each time step the population evolves and we have a new

*generation*. The evolution of the population is a fascinating process to observe because it can generate an incredible variety of patterns (and also puzzles!).

Implementing the game of life in Python is quite straightforward:

import numpy as np def life(X, steps): """ Conway's Game of Life. - X, matrix with the initial state of the game. - steps, number of generations. """ def roll_it(x, y): # rolls the matrix X in a given direction # x=1, y=0 on the left; x=-1, y=0 right; # x=0, y=1 top; x=0, y=-1 down; x=1, y=1 top left; ... return np.roll(np.roll(X, y, axis=0), x, axis=1) for _ in range(steps): # count the number of neighbours # the universe is considered toroidal Y = roll_it(1, 0) + roll_it(0, 1) + roll_it(-1, 0) \ + roll_it(0, -1) + roll_it(1, 1) + roll_it(-1, -1) \ + roll_it(1, -1) + roll_it(-1, 1) # game of life rules X = np.logical_or(np.logical_and(X, Y ==2), Y==3) X = X.astype(int) yield XThe function

*life*takes in input a matrix

*X*which represents the universe of the game where each cell is alive if its corresponding element has value 1 and dead if 0. The function returns the next

*steps*generations. At each time step the number of neighbours of each cell is counted and the rule of the game is applied. Now we can create an universe with an initial state:

X = np.zeros((40, 40)) # 40 by 40 dead cells # R-pentomino X[23, 22:24] = 1 X[24, 21:23] = 1 X[25, 22] = 1This initial state is known as the R-pentomino. It consists of five living cells organized as shown here (image from Wikipedia)

It is by far the most active polyomino with fewer than six cells, all of the others stabilize in at most 10 generations. Let's create a video to visualize the evolution of the system:

from matplotlib import pyplot as plt import matplotlib.animation as manimation FFMpegWriter = manimation.writers['ffmpeg'] metadata = dict(title='Game of life', artist='JustGlowing') writer = FFMpegWriter(fps=10, metadata=metadata) fig = plt.figure() fig.patch.set_facecolor('black') with writer.saving(fig, "game_of_life.mp4", 200): plt.spy(X) plt.axis('off') writer.grab_frame() plt.clf() for x in life(X, 800): plt.spy(x) plt.axis('off') writer.grab_frame() plt.clf()The result is as follows:

In the video we can notice few very well known patters like gliders and blinkers. Also an exploding start at 0:55!

Another implementation, also with videos:

ReplyDeletehttps://datasciencelab.wordpress.com/2014/01/03/yet-another-game-of-life/

Hello Admin,

ReplyDeleteNice blog! I am editor at Web Code Geeks (www.webcodegeeks.com). We have the WCG program (see www.webcodegeeks.com/join-us/wcg/), that I think you’d be perfect for.

If you’re interested, send me an email to eleftheria.drosopoulou@webcodegeeks.com and we can discuss further.

Best regards,

Drosopoulou Eleftheria

This comment has been removed by the author.

ReplyDeleteThanks for the post. What would you recommend as far as Python graphics engines? Should I even bother or look at a different language for that?

ReplyDeleteHi Rob, it really depends on what you what to do. Matplotlib (used here) is good for data visualization. PyQt is a gui framework with very good 2D capabilities, while if you're aiming for 3D I'd recommend you to look at Blender.

Delete