Another brick in the wall

The four types of CA classes namely the trivial (1), the periodic (2), the chaotic (3), and the mix between the period and chaotic (4) should constitute quite a general classification.

I did some tests adding a wall on the left side of the grid … now there are 256 * 8 stamps available, according to the 8 different rules applied at the wall … (I will not post all of them)

plot_000_127
It should be essentially the same level of complexity as in the previous post at least according to the “mantra” by Stephen W.

I will print this stuff and give a look.

As for the previous post … to generate the plots above, I used the following python script:

# Script to generate simple Cellular Automata
# with a wall in the left side of each stamp
# PL 13.VI.2015

import numpy as np
import matplotlib.pyplot as plt

# Aux Functions
########################################

def rule_creator_8(rule):

    a = map(int,bin(rule)[2:].zfill(4)) # rule creator

    return a

def rule_creator_256(rule):

    a = map(int,bin(rule)[2:].zfill(8)) # rule creator

    return a


def CA(rule,cells):

    if len(cells) == 2: 
        a = (-cells[0]+1) * 2 + (-cells[1]+1);

    if len(cells) == 3: 
        a = (-cells[0]+1) * 4 + (-cells[1]+1) *2 + (-cells[2]+1);
 
    return rule[a]   
    
# Main program
########################################

N=30 # Number of Cellular Automata Steps

# memory matrix init

dat=np.zeros([N,N*3+1],np.int)

dat[0,0]=1;

cells3=[0,0,0];
cells2=[0,0];

plt.figure(figsize=(20, 20))

# do the job 

counter = 0;

for rule2 in range(8):

    res2=rule_creator_8(rule2)

    for rule3 in range(256):

        print "Rule Number -->", rule2, " --- ", rule3

        plt.subplot(16,8,(rule3)%128+1)

        res3=rule_creator_256(rule3)

        for stp in np.arange(1,N):

            cells2[0]  = dat[stp-1,0];
            cells2[1]  = dat[stp-1,1];

            dat[stp,0] = CA(res2,cells2);                 # apply the Cellular Automata with rule --> res

            for i in np.arange(1,3*N):
                 
                cells3[0]  = dat[stp-1,i-1];
                cells3[1]  = dat[stp-1,i];
                cells3[2]  = dat[stp-1,i+1];

                dat[stp,i] = CA(res3,cells3);                 # apply the Cellular Automata with rule --> res

#   completed one realization ...

        dat_to_plot=dat[:,0:2*N].copy()                    # plot only the central window

        plt.gca().xaxis.set_major_locator(plt.NullLocator()) # remove ticks and labels
        plt.gca().yaxis.set_major_locator(plt.NullLocator())

        plt.pcolor(dat_to_plot[::-1], cmap='Greys')

        rulenm='rule ' + str(rule3); plt.xlabel(rulenm,fontsize='xx-small')

        if (counter+1)%128 == 0: #plot first page
           file_out = 'plot_' + str(counter-127).zfill(3) + '_' + str(counter).zfill(3) + '.png'
           plt.savefig(file_out, format='png',dpi=900)
           plt.clf()
           plt.figure(figsize=(20, 20))


        counter = counter +1;

print 'EOB'
Annunci

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...