Code speedup tips

[Sean Richards]

Hi,

Just started looking at Python as a tool for investigating 2d Cellular
Automata. I am a complete novice in both disciplines so be gentle (I
don't pretend to be a skilled programmer either) ;) Found some code for
a 1d CA which I have crudely modified to work with 2d CA. I would
appreciate some advice on how to make this code more efficient, as it
already takes about 1 minute with a 200X200 array on a 1.2ghz processor.
I can see that the nested loops are the bottleneck but what better
alternatives does Python have for iterating over a 2d array.  I have
only being playing with Python for a very short time and there is so
much out there that I am getting myself a bit lost in all the
information. Anyway here is the code with a *very* simple rule as an
example - read it and weep :)

----8<-----------------------------------------------------------------

# Simple cellular automata - code 1022
# Rule specifies that a cell should become black if any
# of its neighbours were black on previous step
# Original code by Frank Buss - http://www.frank-buss.de/automaton/rule30.html

# import the Numeric module - used for the arrays
from Numeric import *
# import the Tk module - used to display the CA
from Tkinter import *

def CA_Function(Length):
    # Create the two lattices
    current = zeros((Length,Length),Int)
    next = zeros((Length,Length),Int)

    # Set the start cell to black
    current[len(current)/2,len(current)/2] = 1
    next[len(current)/2,len(current)/2] = 1

    # Apply the rule
    for step in xrange(1,(Length/2)-1):
        for i in xrange(1,len(current)-1):
            for j in xrange(1,len(current)-1):
                if current[i-1,j]== 1 or current[i,j-1]== 1 or \
                    current[i,j+1]== 1 or current[i+1,j]== 1:
                    next[i,j]  = 1
        # Swap the lattices at each step
        (current,next) = (next,current)
    # Draw the lattice
    CA_Draw(current)

def CA_Draw(Lattice):
    for x in range(1,len(Lattice)-1):
        for y in range(1,len(Lattice)-1):
            if Lattice[x,y]:
                img.put("black",(x,y))
            else:
                img.put("white",(x,y))


# Initialise the Tk interface
root = Tk()
root.title('2d CA')

# Create the empty image
Length = 200
img=PhotoImage(width=Length,height=Length)

# Apply the function
CA_Function(Length)

# Display image
lbl=Label(root,image=img)
lbl.pack()
root.mainloop()

----8<-----------------------------------------------------------------

On the 200x200 array that gives me 40,000 elements, I go over the entire
array 100 times -> 4,000,000 iterations
Then to fill the image is another 200x200 operations -> 40,000

Any tips on how to make this more efficient would be greatly appreciated.

Sean

-- 
+---------------------------------------------------------------+
| All spelling errors are intentional and are there to show new |
| and improved ways of spelling old words.                      |
+---------------------------------------------------------------+