ConwayLife.com

A for awesome wrote:4-cell methuselah lasts 3851 gens and produces a 2479-cell SL:

Code: Select all

x = 3, y = 4, rule = B2-a5_S135678
bo$bo$2bo$o!

drc wrote:RULE?

@RULE B2-a5_S135678
@TABLE
n_states:2
neighborhood:Moore
symmetries:rotate8reflect
0,1,0,1,0,0,0,0,0,1
0,1,0,0,1,0,0,0,0,1
0,1,0,0,0,1,0,0,0,1
0,0,0,0,1,1,1,1,1,1
0,0,0,1,0,1,1,1,1,1
0,0,0,1,1,0,1,1,1,1
0,0,0,1,1,1,0,1,1,1
0,0,0,1,1,1,1,0,1,1
0,0,0,1,1,1,1,1,0,1
0,0,1,0,1,0,1,1,1,1
0,0,1,0,1,1,0,1,1,1
0,0,1,1,0,1,0,1,1,1
0,1,0,1,0,1,0,1,1,1
1,0,0,0,0,0,0,0,0,0
1,1,1,0,0,0,0,0,0,0
1,1,0,1,0,0,0,0,0,0
1,1,0,0,1,0,0,0,0,0
1,1,0,0,0,1,0,0,0,0
1,1,1,1,1,0,0,0,0,0
1,1,1,1,0,1,0,0,0,0
1,1,1,1,0,0,1,0,0,0
1,1,1,0,1,1,0,0,0,0
1,1,1,0,1,0,1,0,0,0
1,1,1,0,1,0,0,1,0,0
1,1,1,0,1,0,0,0,1,0
1,1,1,0,0,1,1,0,0,0
1,1,1,0,0,1,0,1,0,0
1,1,1,0,0,1,0,0,1,0
1,1,1,0,0,0,1,1,0,0
1,1,0,1,0,1,0,1,0,0
1,0,1,0,1,0,1,0,1,0

A for awesome wrote:

drc wrote:RULE?

Here:

Code: Select all

@RULE B2-a5_S135678...

A for awesome wrote:A microreflector (repeat time 17) in a non-totalistic rule:

Code: Select all

x = 14, y = 13, rule = B2ce3ai_S23
8b2o$8b2o2$9b2o$9b2ob2o$12b2o3$2o2b2o$2o2b2o$9bo$8bobo$8bobo!

I think this rule might be omniperiodic. The only true periods I haven't seen are 7, 11-12, and 14-15.

Sphenocorona wrote:Here's some non-trivial oscillators for all periods from 2 to 18 in 2ce3ai, plus a few larger periods (such as 43):

Code: Select all

x = 170, y = 121, rule = B2ce3ai_S23
139b2o$139b2o$obobo12bobo$20bo122b2o$4bo29bobo8b2o3b2o23bo2bo45bo2bobo
13b2o$19bo26bobo2bo30bo59bo$obobo27bo3bo6b3o2b2o2b2o21bo2bo3bo41bo2bo
3bo$20bo22bo2bo3bo2bo83b2o5b2o$o10bo5bobo12bobobo8bo5bo23bo2bobobo4bob
obobobobo5bobobobobobobobo6bo4bo8bo5bo$23b2o19b2o4b2o84bo2bobobo2bo$ob
obo6bo11bo12bo14bob2o20bo6bo41bo2bo3bo4b2o2b3o2b2o$25bo24bo2b2o83bo5bo
$22b3o7bobo15bo24bo6bo41bo4bobo6b7o$22bo2bo22b2o2bo$24bo21b2o3b2o87b4o
$23b2o21bo2bo90bo2bo$48b2o4$98bo2bo$o18b2o77b4o$4bo6b2o3b2o2bo25bo$o3b
o6bo2b2o2bo27bo49b7o$13bo4bo11bo2bobobo25b2o10bo2bobobo9b2o2bo5bo$obob
o8bobo3bo35b2o3b2o2bo27bo2bo2b3o2b2o$14bo4bo10bo2bo3bo4b2o5b2o4bo2b2o
2bo12bo2bo15bo2bo3bo2bo$4bo9bo2b2o24bo5bo7bo2bo2bo29bo2bo5bo$12bo2b2o
3bo9bo2bo3bo3bo2bobobo2bo4bo3bob2o11bo2bobo10b2o2b2o5b2o$4bo7b2o5b2o
20b2o2b3o2b2o4bo4bobob2o24bo2bo$30bo2bo3bo5bo5bo7bo4bo2b2o8bo6bo5b2obo
bob2o$43b7o5bobo4bo26bobobo2bo$30bo2bobobo17b2o3b2o13bo2bobo8bobobob2o
5bo$45b4o9bobo2bo24b2obo2bo2bo3b2o53b2o$45bo2bo9b2o2bob2o25b2o2b2o59bo
2bo$61b2obo28bo2bo57b2o2b2o4b2o$64bo28b2o56b2obo2bo6b2o$64b2o86bobobo$
152bobob2o$142b2o3b2o2b2obobo$124bobobo2bo8b2o2b2o2bo5bo2bo$obobo14b2o
71b2o44b2o6bo7b2o2b2o5b2o$15b2o2bo2bo20b2o47b2o4b2o28bo2bo7bo7bo8bo2bo
5bo$o14b2obo2b2o20bo2bo51b2o37bo8b2o9bo2bobobo2bo$18bo11bo2bo11b2o28bo
2bobobo8b4o31bo4bo5b2ob2o5bob2o4bo2bo2b3o2b2o$obobo10b4ob2o69bo2bo2bo
43bo4bo2b2o4b2o2bo5bo$13b2o5bo9bo2bo8b2o5b2o24bo2bo18bo26bo6bo7bo2b2o
2bo12b7o$4bo6bo2bo7bo20bo5bo45bo43b2o3b2o2bo$11b2o8b2o7bo2bo7bo2bo3bo
2bo23bo2bobobo9b2o5b2o23bobobo2bo15b2o12b4o$obobo36b2o2b3o2b2o41bo5bo
61bo2bo$30bo2bo9bo5bo25bo2bo3bo8bo2bobobo2bo$43b7o41b2o2b3o2b2o$30bo2b
o41bo2bobo12bo5bo$45b4o44b7o$45bo2bo96bo2bo19b2o$95b4o46b4o17bo2bo$95b
o2bo65bob2o$143b7o12bob2o$48bo2bo91bo5bo10bob2o$48b4o89b2o2b3o2b2o6bob
2o$141bo2bobobo2bo4bob2o$2bobo41b7o71bobobo2bobobo7bo5bo4bob2o$46bo5bo
89b2o5b2o3b2o$o43b2o2b3o2b2o73bo6bo$30bo2bobobo6bo2bobobo2bo$obobo7bob
obobo27bo5bo73bobo2bobo$30bo6bo3b2o2b2o5b2o$o3bo36b2o12bo72bo2bo13b2o
5b2o$30bo2bobo17b3o4bobobobobobobobo71bo5bo$obo39b3o79bobobo2bobobo8bo
2bobobo2bo$30bo2bo8bo12b2o3bobobobobobobobo69b2o2b3o2b2o$44b2o5b2o2b2o
89bo5bo$30bo2bobobo7bo5bo94b7o$43bo2bobobo2bo$43b2o2b3o2b2o94b4o$45bo
5bo96bo2bo$45b7o2$47b4o$47bo2bo2$obobo8b2o5b2o24bo2bo46b2o53b2o$13bo3b
2o2bo24b4o46b2o53bo2bo$4bo10b2o2bo129b2o2b2o$14bo5bo9bo2bobobo6b7o23bo
2bobobo13b4o25bobobo2bobobo10b2obo2bo6b2o$4bo9bobo3bo23bo5bo44bo2bo48b
obobo7b2o$11b2ob2o4bob2o4bobo6bo4b2o2b3o2b2o21bo6bo46bo2bo3bo11bobob2o
$4bo6b2o6bo3bo18bo2bobobo2bo93b2obobo$16b2obobo8bo4bo8bo5bo23bo4bo10b
2o6b2o26bobo2bobobo13bo2bo$4bo11bo2bob2o20b2o5b2o36bo2bo6bo50b2o2b2o5b
2o$18b2o10bo6bo36bo4bo8b2o2b2obobo2bo27bo2bo3bo15bo2bo5bo$90bo3b3o2b2o
51bo2bobobo2bo$30bo2bobobo6b2o5b2o21bo4bo10b2o6bo25bobobo2bobobo14bo2b
o2b3o2b2o$45bo5bo41b2o2b2o51b2o2bo5bo$43bo2bobobo2bo39b2o59b7o$43b2o2b
3o2b2o$45bo5bo104b4o$45b7o104bo2bo2$47b4o$47bo2bo$obobo10b2o2b2o$15b2o
2b2o$o3bo$13b7o104b2o$obobo8bo5bo104bo2bo2b2o$11b2o2b3o2b2o100b2o2b2o
2b2o$o3bo6bo2bo3bo2bo97b2obo2bo$13bo5bo80bo6bobobo8bobobo7b2o$obobo7b
2o5b2o83bo15bobobo7b2o$25bobobobobobobobo60bo3bo6bo7b2obobo$15b2o105bo
2bo$15b2o8bobobobobobobobo60bobobo4bo12b2o2b2o2bo2b2o$124bo2bobobobo$
25bobobobobobobobo64bo6bo13bo2bo3bo2bo$123bo2bo2b3o2b2o$25bobobobobobo
bobo64bo2bobobo11b2o2bo5bo$127b7o2$129b4o$129bo2bo!

That little p10 oscillator with the isolated pip spark was probably the most important finding in all of this, it provided an extremely easily manipulated ignition source for restarting the cycle over once any smoke clears out of the way. It's also very easy to phase shift.

Now that we know this rule is omniperiodic, the next problem is building circuits (or finding new spaceships)...

drc wrote: I think we should make a list of rules that are omniperiodic:

B2ce3ai/S23

To do:

B3/S23 (I honestly don't know how litely.
B3/S234 (probably)

BlinkerSpawn wrote:

drc wrote: I think we should make a list of rules that are omniperiodic:

B2ce3ai/S23

To do:

B3/S23 (I honestly don't know how litely.
B3/S234 (probably)

I hope you're limiting that to rules close to Life, because there's tons more than those.
B3/S234 was proven omniperiodic some time ago, just check the dedicated thread I bumped some weeks ago.

A for awesome wrote:

Code: Select all

x = 22, y = 22, rule = B3-kq4j_S23
7b2o$7b2o$10b2o$9bo$10bo3$6bo8b2o3b2o$4b2o9bobo2b2o$5b2o8bo3$6bo8b2o$
2o2bobo9b2o$2o3b2o8bo3$11bo$12bo$10b2o$13b2o$13b2o!

x = 8, y = 8, rule = B3-kq4j_S23
2o4b2o$2o4b2o2$2bobo$2b2o$3bo$2o4b2o$2o4b2o!

drc wrote:B2aen/S1e2i is similar to cb2, it's pretty cool. Despite what you might think at first, it is NOT the same as cb2.

In cb2, this pattern turns into a moon, but in B2aen/S1e2i is a growing rake, front c, back c/2:

Code: Select all

x = 6, y = 6, rule = B2aen_S1e2i
2b2o$bo2bo$o4bo$3bo$3bo$3bo!

A p6 oscillator:

Code: Select all

x = 4, y = 4, rule = B2aen_S1e2i
o$bo$2bo$3bo!

A p6 flip-flop glide-symmetric rake:

Code: Select all

x = 7, y = 3, rule = B2aen_S1e2i
b2ob2o$o3bobo$4bo!

Tagalongs:

Code: Select all

x = 13, y = 5, rule = B2aen_S1e2i
b2o7b2o$o2bo5bo2bo$8bo$bo$8bo!

P4 rake:

Code: Select all

x = 8, y = 4, rule = B2aen_S1e2i
b2o$o2bo$5b2o$7bo!

P16 rake:

Code: Select all

x = 9, y = 11, rule = B2aen_S1e2i
o$bo$2bo$3bo$4bo$5bo$6bo$7bo$8bo$8bo$7bo!

Splitter rake:

Code: Select all

x = 16, y = 15, rule = B2aen_S1e2i
7bo$8bo$8bo$7bo$o12bo$bo4bo5bobo$5bo9bo$15bo$12bobo$bo7b2o2bo$bo8bo$9b
o$12bo$12bo$11bo!

muzik wrote:Can you give me the rule sheet thing?

# isotropic-rule-gen.py, version 1.1
# Change from v1.0:
#    added @ICONS section to output rule, to avoid triggering shared-rule logic in Golly
#
# isotropic-rule.py / isotropicRulegen.py
# Auxillary rule generator from wildmyron's non-totalistic version of apgsearch
# The rulespace is the set of isotropic non-totalistic rules on the Moore
# neighbourhood, using Alan Hensel's notation.
# See http://www.ibiblio.org/lifepatterns/neighbors2.html
# Generate a rule table for an isotropic rule using Alan Hensel's
# isotropic, non-totalistic rule format for CA on the Moore neighbourhood

import golly as g
import os

# Generates the helper rules for apgsearch-isotropic, given a base isotropic 
# rule in Hensel's notation.
class RuleGenerator:

    # notationdict adapted from Eric Goldstein's HenselNotation->Ruletable(1.3).py
    # Modified for neighbourhood2 version of Hensel's notation
    notationdict = {
        "0"  : [0,0,0,0,0,0,0,0],   #    
        "1e" : [1,0,0,0,0,0,0,0],   #   N
        "1c" : [0,1,0,0,0,0,0,0],   #   NE
        "2a" : [1,1,0,0,0,0,0,0],   #   N,  NE
        "2e" : [1,0,1,0,0,0,0,0],   #   N,  E
        "2k" : [1,0,0,1,0,0,0,0],   #   N,  SE
        "2i" : [1,0,0,0,1,0,0,0],   #   N,  S
        "2c" : [0,1,0,1,0,0,0,0],   #   NE, SE
        "2n" : [0,1,0,0,0,1,0,0],   #   NE, SW
        "3a" : [1,1,1,0,0,0,0,0],   #   N,  NE, E
        "3n" : [1,1,0,1,0,0,0,0],   #   N,  NE, SE
        "3r" : [1,1,0,0,1,0,0,0],   #   N,  NE, S
        "3q" : [1,1,0,0,0,1,0,0],   #   N,  NE, SW
        "3j" : [1,1,0,0,0,0,1,0],   #   N,  NE, W
        "3i" : [1,1,0,0,0,0,0,1],   #   N,  NE, NW
        "3e" : [1,0,1,0,1,0,0,0],   #   N,  E,  S
        "3k" : [1,0,1,0,0,1,0,0],   #   N,  E,  SW
        "3y" : [1,0,0,1,0,1,0,0],   #   N,  SE, SW
        "3c" : [0,1,0,1,0,1,0,0],   #   NE, SE, SW
        "4a" : [1,1,1,1,0,0,0,0],   #   N,  NE, E,  SE
        "4r" : [1,1,1,0,1,0,0,0],   #   N,  NE, E,  S
        "4q" : [1,1,1,0,0,1,0,0],   #   N,  NE, E,  SW
        "4i" : [1,1,0,1,1,0,0,0],   #   N,  NE, SE, S
        "4y" : [1,1,0,1,0,1,0,0],   #   N,  NE, SE, SW
        "4k" : [1,1,0,1,0,0,1,0],   #   N,  NE, SE, W
        "4n" : [1,1,0,1,0,0,0,1],   #   N,  NE, SE, NW
        "4z" : [1,1,0,0,1,1,0,0],   #   N,  NE, S,  SW
        "4j" : [1,1,0,0,1,0,1,0],   #   N,  NE, S,  W
        "4t" : [1,1,0,0,1,0,0,1],   #   N,  NE, S,  NW
        "4w" : [1,1,0,0,0,1,1,0],   #   N,  NE, SW, W
        "4e" : [1,0,1,0,1,0,1,0],   #   N,  E,  S,  W
        "4c" : [0,1,0,1,0,1,0,1],   #   NE, SE, SW, NW
        "5i" : [1,1,1,1,1,0,0,0],   #   N,  NE, E,  SE, S
        "5j" : [1,1,1,1,0,1,0,0],   #   N,  NE, E,  SE, SW
        "5n" : [1,1,1,1,0,0,1,0],   #   N,  NE, E,  SE, W
        "5a" : [1,1,1,1,0,0,0,1],   #   N,  NE, E,  SE, NW
        "5q" : [1,1,1,0,1,1,0,0],   #   N,  NE, E,  S,  SW
        "5c" : [1,1,1,0,1,0,1,0],   #   N,  NE, E,  S,  W
        "5r" : [1,1,0,1,1,1,0,0],   #   N,  NE, SE, S,  SW
        "5y" : [1,1,0,1,1,0,1,0],   #   N,  NE, SE, S,  W
        "5k" : [1,1,0,1,0,1,1,0],   #   N,  NE, SE, SW, W
        "5e" : [1,1,0,1,0,1,0,1],   #   N,  NE, SE, SW, NW
        "6a" : [1,1,1,1,1,1,0,0],   #   N,  NE, E,  SE, S,  SW
        "6c" : [1,1,1,1,1,0,1,0],   #   N,  NE, E,  SE, S,  W
        "6k" : [1,1,1,1,0,1,1,0],   #   N,  NE, E,  SE, SW, W
        "6e" : [1,1,1,1,0,1,0,1],   #   N,  NE, E,  SE, SW, NW
        "6n" : [1,1,1,0,1,1,1,0],   #   N,  NE, E,  S,  SW, W
        "6i" : [1,1,0,1,1,1,0,1],   #   N,  NE, SE, S,  SW, NW
        "7c" : [1,1,1,1,1,1,1,0],   #   N,  NE, E,  SE, S,  SW, W
        "7e" : [1,1,1,1,1,1,0,1],   #   N,  NE, E,  SE, S,  SW, NW
        "8"  : [1,1,1,1,1,1,1,1],   #   N,  NE, E,  SE, S,  SW, W,  NW
        }
    
    allneighbours = [  
        ["0"],
        ["1e", "1c"],
        ["2a", "2e", "2k", "2i", "2c", "2n"],
        ["3a", "3n", "3r", "3q", "3j", "3i", "3e", "3k", "3y", "3c"],
        ["4a", "4r", "4q", "4i", "4y", "4k", "4n", "4z", "4j", "4t", "4w", "4e", "4c"],
        ["5i", "5j", "5n", "5a", "5q", "5c", "5r", "5y", "5k", "5e"],
        ["6a", "6c", "6k", "6e", "6n", "6i"],
        ["7c", "7e"],
        ["8"],
        ]
        
    allneighbours_flat = [n for x in allneighbours for n in x]
    
    numneighbours = len(notationdict)
    
    # Use dict to store rule elements, initialised by setrule():
    bee = {}
    ess = {}
    alphanumeric = ""
    rulename = ""
    
    # Save the isotropic rule
    def saveAllRules(self):    
        self.saveIsotropicRule()
    
    # Interpret birth or survival string
    def ruleparts(self, part):

        inverse = False
        nlist = []
        totalistic = True
        rule = { k: False for k, v in self.notationdict.iteritems() }
        
        # Reverse the rule string to simplify processing
        part = part[::-1]
        
        for c in part:
            if c.isdigit():
                d = int(c)
                if totalistic:
                    # Add all the neighbourhoods for this value
                    for neighbour in self.allneighbours[d]:
                        rule[neighbour] = True
                elif inverse:
                    # Add all the neighbourhoods not in nlist for this value
                    for neighbour in self.allneighbours[d]:
                        if neighbour[1] not in nlist:
                            rule[neighbour] = True
                else:
                    # Add all the neighbourhoods in nlist for this value
                    for n in nlist:
                        neighbour = c + n
                        if neighbour in rule:
                            rule[neighbour] = True
                        else:
                            # Error
                            return {}
                    
                inverse = False
                nlist = []
                totalistic = True

            elif (c == '-'):
                inverse = True

            else:
                totalistic = False
                nlist.append(c)
        
        return rule

    # Set isotropic, non-totalistic rule
    # Adapted from Eric Goldstein's HenselNotation->Ruletable(1.3).py
    def setrule(self, rulestring):
    
        # neighbours_flat = [n for x in neighbours for n in x]
        b = {}
        s = {}
        sep = ''
        birth = ''
        survive = ''
        
        rulestring = rulestring.lower()
        
        if '/' in rulestring:
            sep = '/'
        elif '_' in rulestring:
            sep = '_'
        elif (rulestring[0] == 'b'):
            sep = 's'
        else:
            sep = 'b'
        
        survive, birth = rulestring.split(sep)
        if (survive[0] == 'b'):
            survive, birth = birth, survive
        survive = survive.replace('s', '')
        birth = birth.replace('b', '')
        
        b = self.ruleparts(birth)
        s = self.ruleparts(survive)

        if b and s:
            self.alphanumeric = 'B' + birth + 'S' + survive
            self.rulename = 'B' + birth + '_S' + survive
            self.bee = b
            self.ess = s
        else:
            # Error
            g.note("Unable to process rule definition.\n" +
                    "b = " + str(b) + "\ns = " + str(s))
            g.exit()
            

    # Save a rule file:
    def saverule(self, name, comments, table, colours):
        
        ruledir = g.getdir("rules")
        filename = ruledir + name + ".rule"

        results = "@RULE " + name + "\n\n"
        results += "*** File autogenerated by saverule. ***\n\n"
        results += comments
        results += "\n\n@TABLE\n\n"
        results += table
        results += "\n\n@COLORS\n\n"
        results += colours
        results += "\n\n@ICONS\n\n"
        results += "circles\n"

        # Only create a rule file if it doesn't already exist; this avoids
        # concurrency issues when booting an instance of apgsearch whilst
        # one is already running.
        if not os.path.exists(filename):
            try:
                f = open(filename, 'w')
                f.write(results)
                f.close()
            except:
                g.warn("Unable to create rule table:\n" + filename)

    # Defines a variable:
    def newvar(self, name, vallist):

        line = "var "+name+"={"
        for i in xrange(len(vallist)):
            if (i > 0):
                line += ','
            line += str(vallist[i])
        line += "}\n"

        return line

    # Defines a block of equivalent variables:
    def newvars(self, namelist, vallist):

        block = "\n"

        for name in namelist:
            block += self.newvar(name, vallist)

        return block

    def scoline(self, chara, charb, left, right, amount):

        line = str(left) + ","

        for i in xrange(8):
            if (i < amount):
                line += chara
            else:
                line += charb
            line += chr(97 + i)
            line += ","

        line += str(right) + "\n"

        return line

    def isotropicline(self, chara, charb, left, right, n):

        line = str(left) + ","
        neighbours = self.notationdict[n]
        
        for i in xrange(8):
            if neighbours[i]:
                line += chara
            else:
                line += charb
            line += chr(97 + i)
            line += ","

        line += str(right) + "\n"

        return line
        
    def saveIsotropicRule(self):
    
        comments = """
This is a two state, isotropic, non-totalistic rule on the Moore neighbourhood.
The notation used to define the rule was originally proposed by Alan Hensel.
See http://www.ibiblio.org/lifepatterns/neighbors2.html for details
"""

        table = """
n_states:2
neighborhood:Moore
symmetries:rotate4reflect
"""

        table += self.newvars(["a","b","c","d","e","f","g","h"], [0, 1])

        table += "\n# Birth\n"
        for n in self.allneighbours_flat:
            if self.bee[n]:
                table += "0,"
                table += str(self.notationdict[n])[1:-1].replace(' ','')
                table += ",1\n"
        
        table += "\n# Survival\n"
        for n in self.allneighbours_flat:
            if self.ess[n]:
                table += "1,"
                table += str(self.notationdict[n])[1:-1].replace(' ','')
                table += ",1\n"

        table += "\n# Death\n"
        table += self.scoline("","",1,0,0)
        
        colours = ""
        self.saverule(self.rulename, comments, table, colours)

rulestring = g.getstring("Enter rule string in Alan Hensel's isotropic rule notation", 
                         "B2-a/S12")

rg = RuleGenerator()

rg.setrule(rulestring)
rg.saveIsotropicRule()
g.setrule(rg.rulename)

g.show("Created rule in file: " + rg.rulename + ".rule")

drc wrote:

muzik wrote:Can you give me the rule sheet thing?

Code: Select all

# isotropic-rule-gen.py, version 1.1
# Change from v1.0:
#    added @ICONS section to output rule, to avoid triggering shared-rule logic in Golly
#
# isotropic-rule.py / isotropicRulegen.py
# Auxillary rule generator from wildmyron's non-totalistic version of apgsearch
# The rulespace is the set of isotropic non-totalistic rules on the Moore
# neighbourhood, using Alan Hensel's notation.
# See http://www.ibiblio.org/lifepatterns/neighbors2.html
# Generate a rule table for an isotropic rule using Alan Hensel's
# isotropic, non-totalistic rule format for CA on the Moore neighbourhood

import golly as g
import os

# Generates the helper rules for apgsearch-isotropic, given a base isotropic 
# rule in Hensel's notation.
class RuleGenerator:

    # notationdict adapted from Eric Goldstein's HenselNotation->Ruletable(1.3).py
    # Modified for neighbourhood2 version of Hensel's notation
    notationdict = {
        "0"  : [0,0,0,0,0,0,0,0],   #    
        "1e" : [1,0,0,0,0,0,0,0],   #   N
        "1c" : [0,1,0,0,0,0,0,0],   #   NE
        "2a" : [1,1,0,0,0,0,0,0],   #   N,  NE
        "2e" : [1,0,1,0,0,0,0,0],   #   N,  E
        "2k" : [1,0,0,1,0,0,0,0],   #   N,  SE
        "2i" : [1,0,0,0,1,0,0,0],   #   N,  S
        "2c" : [0,1,0,1,0,0,0,0],   #   NE, SE
        "2n" : [0,1,0,0,0,1,0,0],   #   NE, SW
        "3a" : [1,1,1,0,0,0,0,0],   #   N,  NE, E
        "3n" : [1,1,0,1,0,0,0,0],   #   N,  NE, SE
        "3r" : [1,1,0,0,1,0,0,0],   #   N,  NE, S
        "3q" : [1,1,0,0,0,1,0,0],   #   N,  NE, SW
        "3j" : [1,1,0,0,0,0,1,0],   #   N,  NE, W
        "3i" : [1,1,0,0,0,0,0,1],   #   N,  NE, NW
        "3e" : [1,0,1,0,1,0,0,0],   #   N,  E,  S
        "3k" : [1,0,1,0,0,1,0,0],   #   N,  E,  SW
        "3y" : [1,0,0,1,0,1,0,0],   #   N,  SE, SW
        "3c" : [0,1,0,1,0,1,0,0],   #   NE, SE, SW
        "4a" : [1,1,1,1,0,0,0,0],   #   N,  NE, E,  SE
        "4r" : [1,1,1,0,1,0,0,0],   #   N,  NE, E,  S
        "4q" : [1,1,1,0,0,1,0,0],   #   N,  NE, E,  SW
        "4i" : [1,1,0,1,1,0,0,0],   #   N,  NE, SE, S
        "4y" : [1,1,0,1,0,1,0,0],   #   N,  NE, SE, SW
        "4k" : [1,1,0,1,0,0,1,0],   #   N,  NE, SE, W
        "4n" : [1,1,0,1,0,0,0,1],   #   N,  NE, SE, NW
        "4z" : [1,1,0,0,1,1,0,0],   #   N,  NE, S,  SW
        "4j" : [1,1,0,0,1,0,1,0],   #   N,  NE, S,  W
        "4t" : [1,1,0,0,1,0,0,1],   #   N,  NE, S,  NW
        "4w" : [1,1,0,0,0,1,1,0],   #   N,  NE, SW, W
        "4e" : [1,0,1,0,1,0,1,0],   #   N,  E,  S,  W
        "4c" : [0,1,0,1,0,1,0,1],   #   NE, SE, SW, NW
        "5i" : [1,1,1,1,1,0,0,0],   #   N,  NE, E,  SE, S
        "5j" : [1,1,1,1,0,1,0,0],   #   N,  NE, E,  SE, SW
        "5n" : [1,1,1,1,0,0,1,0],   #   N,  NE, E,  SE, W
        "5a" : [1,1,1,1,0,0,0,1],   #   N,  NE, E,  SE, NW
        "5q" : [1,1,1,0,1,1,0,0],   #   N,  NE, E,  S,  SW
        "5c" : [1,1,1,0,1,0,1,0],   #   N,  NE, E,  S,  W
        "5r" : [1,1,0,1,1,1,0,0],   #   N,  NE, SE, S,  SW
        "5y" : [1,1,0,1,1,0,1,0],   #   N,  NE, SE, S,  W
        "5k" : [1,1,0,1,0,1,1,0],   #   N,  NE, SE, SW, W
        "5e" : [1,1,0,1,0,1,0,1],   #   N,  NE, SE, SW, NW
        "6a" : [1,1,1,1,1,1,0,0],   #   N,  NE, E,  SE, S,  SW
        "6c" : [1,1,1,1,1,0,1,0],   #   N,  NE, E,  SE, S,  W
        "6k" : [1,1,1,1,0,1,1,0],   #   N,  NE, E,  SE, SW, W
        "6e" : [1,1,1,1,0,1,0,1],   #   N,  NE, E,  SE, SW, NW
        "6n" : [1,1,1,0,1,1,1,0],   #   N,  NE, E,  S,  SW, W
        "6i" : [1,1,0,1,1,1,0,1],   #   N,  NE, SE, S,  SW, NW
        "7c" : [1,1,1,1,1,1,1,0],   #   N,  NE, E,  SE, S,  SW, W
        "7e" : [1,1,1,1,1,1,0,1],   #   N,  NE, E,  SE, S,  SW, NW
        "8"  : [1,1,1,1,1,1,1,1],   #   N,  NE, E,  SE, S,  SW, W,  NW
        }
    
    allneighbours = [  
        ["0"],
        ["1e", "1c"],
        ["2a", "2e", "2k", "2i", "2c", "2n"],
        ["3a", "3n", "3r", "3q", "3j", "3i", "3e", "3k", "3y", "3c"],
        ["4a", "4r", "4q", "4i", "4y", "4k", "4n", "4z", "4j", "4t", "4w", "4e", "4c"],
        ["5i", "5j", "5n", "5a", "5q", "5c", "5r", "5y", "5k", "5e"],
        ["6a", "6c", "6k", "6e", "6n", "6i"],
        ["7c", "7e"],
        ["8"],
        ]
        
    allneighbours_flat = [n for x in allneighbours for n in x]
    
    numneighbours = len(notationdict)
    
    # Use dict to store rule elements, initialised by setrule():
    bee = {}
    ess = {}
    alphanumeric = ""
    rulename = ""
    
    # Save the isotropic rule
    def saveAllRules(self):    
        self.saveIsotropicRule()
    
    # Interpret birth or survival string
    def ruleparts(self, part):

        inverse = False
        nlist = []
        totalistic = True
        rule = { k: False for k, v in self.notationdict.iteritems() }
        
        # Reverse the rule string to simplify processing
        part = part[::-1]
        
        for c in part:
            if c.isdigit():
                d = int(c)
                if totalistic:
                    # Add all the neighbourhoods for this value
                    for neighbour in self.allneighbours[d]:
                        rule[neighbour] = True
                elif inverse:
                    # Add all the neighbourhoods not in nlist for this value
                    for neighbour in self.allneighbours[d]:
                        if neighbour[1] not in nlist:
                            rule[neighbour] = True
                else:
                    # Add all the neighbourhoods in nlist for this value
                    for n in nlist:
                        neighbour = c + n
                        if neighbour in rule:
                            rule[neighbour] = True
                        else:
                            # Error
                            return {}
                    
                inverse = False
                nlist = []
                totalistic = True

            elif (c == '-'):
                inverse = True

            else:
                totalistic = False
                nlist.append(c)
        
        return rule

    # Set isotropic, non-totalistic rule
    # Adapted from Eric Goldstein's HenselNotation->Ruletable(1.3).py
    def setrule(self, rulestring):
    
        # neighbours_flat = [n for x in neighbours for n in x]
        b = {}
        s = {}
        sep = ''
        birth = ''
        survive = ''
        
        rulestring = rulestring.lower()
        
        if '/' in rulestring:
            sep = '/'
        elif '_' in rulestring:
            sep = '_'
        elif (rulestring[0] == 'b'):
            sep = 's'
        else:
            sep = 'b'
        
        survive, birth = rulestring.split(sep)
        if (survive[0] == 'b'):
            survive, birth = birth, survive
        survive = survive.replace('s', '')
        birth = birth.replace('b', '')
        
        b = self.ruleparts(birth)
        s = self.ruleparts(survive)

        if b and s:
            self.alphanumeric = 'B' + birth + 'S' + survive
            self.rulename = 'B' + birth + '_S' + survive
            self.bee = b
            self.ess = s
        else:
            # Error
            g.note("Unable to process rule definition.\n" +
                    "b = " + str(b) + "\ns = " + str(s))
            g.exit()
            

    # Save a rule file:
    def saverule(self, name, comments, table, colours):
        
        ruledir = g.getdir("rules")
        filename = ruledir + name + ".rule"

        results = "@RULE " + name + "\n\n"
        results += "*** File autogenerated by saverule. ***\n\n"
        results += comments
        results += "\n\n@TABLE\n\n"
        results += table
        results += "\n\n@COLORS\n\n"
        results += colours
        results += "\n\n@ICONS\n\n"
        results += "circles\n"

        # Only create a rule file if it doesn't already exist; this avoids
        # concurrency issues when booting an instance of apgsearch whilst
        # one is already running.
        if not os.path.exists(filename):
            try:
                f = open(filename, 'w')
                f.write(results)
                f.close()
            except:
                g.warn("Unable to create rule table:\n" + filename)

    # Defines a variable:
    def newvar(self, name, vallist):

        line = "var "+name+"={"
        for i in xrange(len(vallist)):
            if (i > 0):
                line += ','
            line += str(vallist[i])
        line += "}\n"

        return line

    # Defines a block of equivalent variables:
    def newvars(self, namelist, vallist):

        block = "\n"

        for name in namelist:
            block += self.newvar(name, vallist)

        return block

    def scoline(self, chara, charb, left, right, amount):

        line = str(left) + ","

        for i in xrange(8):
            if (i < amount):
                line += chara
            else:
                line += charb
            line += chr(97 + i)
            line += ","

        line += str(right) + "\n"

        return line

    def isotropicline(self, chara, charb, left, right, n):

        line = str(left) + ","
        neighbours = self.notationdict[n]
        
        for i in xrange(8):
            if neighbours[i]:
                line += chara
            else:
                line += charb
            line += chr(97 + i)
            line += ","

        line += str(right) + "\n"

        return line
        
    def saveIsotropicRule(self):
    
        comments = """
This is a two state, isotropic, non-totalistic rule on the Moore neighbourhood.
The notation used to define the rule was originally proposed by Alan Hensel.
See http://www.ibiblio.org/lifepatterns/neighbors2.html for details
"""

        table = """
n_states:2
neighborhood:Moore
symmetries:rotate4reflect
"""

        table += self.newvars(["a","b","c","d","e","f","g","h"], [0, 1])

        table += "\n# Birth\n"
        for n in self.allneighbours_flat:
            if self.bee[n]:
                table += "0,"
                table += str(self.notationdict[n])[1:-1].replace(' ','')
                table += ",1\n"
        
        table += "\n# Survival\n"
        for n in self.allneighbours_flat:
            if self.ess[n]:
                table += "1,"
                table += str(self.notationdict[n])[1:-1].replace(' ','')
                table += ",1\n"

        table += "\n# Death\n"
        table += self.scoline("","",1,0,0)
        
        colours = ""
        self.saverule(self.rulename, comments, table, colours)

rulestring = g.getstring("Enter rule string in Alan Hensel's isotropic rule notation", 
                         "B2-a/S12")

rg = RuleGenerator()

rg.setrule(rulestring)
rg.saveIsotropicRule()
g.setrule(rg.rulename)

g.show("Created rule in file: " + rg.rulename + ".rule")

Enter in any rule to auto-generate a rule table

drc wrote:3-g synth of a rake:

Code: Select all

x = 16, y = 9, rule = B2aen_S1e2i
9bo$10bo$10bo$9bo2$o12bo$bo10bo$bo10bo2bo$o12bo!

Converting moon rake into (I'll just call it the spear):

Code: Select all

x = 16, y = 24, rule = B2aen_S1e2i
9b2o$8bo2bob2o$15bo8$bo$o$o$bo2$bo$bo$2bo5$11bo2bo$10bo4bo!

muzik wrote:For some reason the code still isn't generating the rule properly.

Can you make the rule table thing look like the other ones?

@RULE B2aen_S1e2i

*** File autogenerated by saverule. ***


This is a two state, isotropic, non-totalistic rule on the Moore neighbourhood.
The notation used to define the rule was originally proposed by Alan Hensel.
See http://www.ibiblio.org/lifepatterns/neighbors2.html for details


@TABLE


n_states:2
neighborhood:Moore
symmetries:rotate4reflect

var a={0,1}
var b={0,1}
var c={0,1}
var d={0,1}
var e={0,1}
var f={0,1}
var g={0,1}
var h={0,1}

# Birth
0,1,1,0,0,0,0,0,0,1
0,1,0,1,0,0,0,0,0,1
0,0,1,0,0,0,1,0,0,1

# Survival
1,1,0,0,0,0,0,0,0,1
1,1,0,0,0,1,0,0,0,1

# Death
1,a,b,c,d,e,f,g,h,0


@COLORS



@ICONS

circles

drc wrote:

muzik wrote:For some reason the code still isn't generating the rule properly.

Can you make the rule table thing look like the other ones?

Code: Select all

x = 13, y = 19, rule = B2aen_S1e2i
4$bo$obo$bobo$2bobo$3bobo$4bobo$7bo$7bo$6bo!