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

SIMPLE RULES – ANKS plots

plot_000_127plot_128_255

To generate the plots above, I used the following python script:

# Script to generate simple Cellular Automata
# from the book ANKS S Wolfram 2002 pg 55-56
# PL 13.VI.2015

import numpy as np
import matplotlib.pyplot as plt

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

def rule_creator_256(rule):

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

    return a


def CA(rule,cells3):

    a = (-cells3[0]+1) * 4 + (-cells3[1]+1) *2 + (-cells3[2]+1);
 
    return rule[a]   
    
# Main program
########################################

N=30 # Number of Cellular Automata Steps

# memory matrix init

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

dat[0,2*N]=1;

cells3=[0,0,0];

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

# do the job 

for rule in range(256):

    print "Rule Number -->", rule

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

    res=rule_creator_256(rule)

    for stp in np.arange(1,N):
        for i in np.arange(1,4*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(res,cells3);                 # apply the Cellular Automata with rule --> res

#   completed one realization ...

    dat_to_plot=dat[:,N+1:3*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(rule); plt.xlabel(rulenm,fontsize='xx-small')

    if rule == 127: #plot first page
       plt.savefig('plot_000_127.png', format='png',dpi=900)
       plt.clf()
       plt.figure(figsize=(20, 20))

    if rule == 255: #plot second page
       plt.savefig('plot_128_255.png', format='png',dpi=900)
       plt.clf()

print 'EOB'