Just to clarify, you mean "1 if it is required", right?AforAmpere wrote:The code is very unoptimized, but it works. You input new spaceships by putting the RLE in a string in the top list, and the string corresponding to the rule in the bottom. The bottom rule string is what you get when you take each transition in the order below, and for each transition, put a 0 if it is not allowed, a 1 if it is allowed, or a 2 if it does not matter.
Thread for basic non-CGOL questions
Re: Thread for basic non-CGOL questions
-
- Posts: 1334
- Joined: July 1st, 2016, 3:58 pm
Re: Thread for basic non-CGOL questions
Yes, sorry, now edited.
EDIT, here is a script to convert to the rulestring at the bottom:
It takes the minimum rule of the pattern and the maximum rule, and outputs the rule number to your clipboard.
EDIT 2, I've added something that makes it a bit easier. Save this file as gliderlist.py:
That just consists of the ship lists. Then, save this as the new Glider_Database.py:
This addition should allow easier pasting, as all the ships will be contained in a separate document. Format as you wish.
Another EDIT, fixed reloading issue.
EDIT, here is a script to convert to the rulestring at the bottom:
Code: Select all
# torulestring.py, run with Golly.
import golly as g
import os
import sys
g.new("")
class RuleGenerator:
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"
global results
results = ""
results += table
# 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.
# 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):
table = """"""
for n in self.allneighbours_flat:
if self.bee[n]:
table += "1"
else:
table += "0"
for n in self.allneighbours_flat:
if self.ess[n]:
table += "1"
else:
table += "0"
colours = ""
comments = ""
self.saverule(self.rulename, comments, table, colours)
rulestring = g.getstring("Enter minimum rule string:")
rulestring2 = g.getstring("Enter maximum rule string:")
rg = RuleGenerator()
rg.setrule(rulestring)
rg.saveIsotropicRule()
q = results
rg.setrule(rulestring2)
rg.saveIsotropicRule()
t = results
g.setrule(rulestring)
# g.show(results)
final = ""
for z in range(len(q)):
if q[z] == t[z]:
final+=q[z]
else:
final+="2"
g.setclipstr(final)
EDIT 2, I've added something that makes it a bit easier. Save this file as gliderlist.py:
Code: Select all
#gliderlist.py
ships=["b2o$obo$2bo!",
"b3o$o2bo$3bo$3bo$obo!",
"7b2obo$4b2obob2ob3o$b4o2b2o6bo$o4bo3bo3b2o$b2o!",
"b2o$o2bo!",
"b2o$$o2bo!"]
y=["000002202112211222220222222222222202222222222222222200112222211212222222222022222222222222222222222222",
"000002002122211222222222222222222220222222222222022020211122111211222202222222220222022222022220202222",
"000000002111111222200000002002222220220022202222222200111112111111112120000020022222022222222222222222",
"000112222222202222222222222222222222222222222222222220220222222222222222222222222222222222222222222222",
"000121222222022222222222222222222222222222222222222002222222222222222222222222222222222222222222222222"]
Code: Select all
# Glider_Database.py, run with Golly.
import golly as g
import os
import sys
import gliderlist ; reload(gliderlist)
g.new("")
class RuleGenerator:
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"
global results
results = ""
results += table
# 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.
# 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):
table = """"""
for n in self.allneighbours_flat:
if self.bee[n]:
table += "1"
else:
table += "0"
for n in self.allneighbours_flat:
if self.ess[n]:
table += "1"
else:
table += "0"
colours = ""
comments = ""
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(rulestring)
# g.show(results)
p=0
j=0
y=gliderlist.y
ships=gliderlist.ships
for z in range(len(y)):
p = 0
for x in range(len(results)):
if (results[x] == "1" and y[z][x] == "0") or (results[x] == "0" and y[z][x] == "1"):
# g.show(rg.rulename + "False")
p = 1
if p ==0:
# g.show(rg.rulename + "True")
g.setclipstr(ships[z])
g.paste(j,0,"or")
j+=20
Another EDIT, fixed reloading issue.
I manage the 5S project, which collects all known spaceship speeds in Isotropic Non-totalistic rules. I also wrote EPE, a tool for searching in the INT rulespace.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Re: Thread for basic non-CGOL questions
Has anyone attempted to make a 16-state rule where every state represents a combination of cells that fits in a 2x2 square, that simulates a scaled-down version of Life?
Help wanted: How can we accurately notate any 1D replicator?
-
- Posts: 1334
- Joined: July 1st, 2016, 3:58 pm
Re: Thread for basic non-CGOL questions
I did try that at some point, but realized that literal billions of transitions were needed, and gave up.muzik wrote:Has anyone attempted to make a 16-state rule where every state represents a combination of cells that fits in a 2x2 square, that simulates a scaled-down version of Life?
I manage the 5S project, which collects all known spaceship speeds in Isotropic Non-totalistic rules. I also wrote EPE, a tool for searching in the INT rulespace.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
- BlinkerSpawn
- Posts: 1992
- Joined: November 8th, 2014, 8:48 pm
- Location: Getting a snacker from R-Bee's
Re: Thread for basic non-CGOL questions
If you use variables for grouping properly, such that only the subcells adjacent to each cell are checked, you might only need a few thousand, although even that would be best handled by computer.AforAmpere wrote:I did try that at some point, but realized that literal billions of transitions were needed, and gave up.muzik wrote:Has anyone attempted to make a 16-state rule where every state represents a combination of cells that fits in a 2x2 square, that simulates a scaled-down version of Life?
-
- Posts: 1334
- Joined: July 1st, 2016, 3:58 pm
Re: Thread for basic non-CGOL questions
I think that using that method would bring the transitions to around 65536, which is more reasonable.BlinkerSpawn wrote:If you use variables for grouping properly, such that only the subcells adjacent to each cell are checked, you might only need a few thousand, although even that would be best handled by computer.
I manage the 5S project, which collects all known spaceship speeds in Isotropic Non-totalistic rules. I also wrote EPE, a tool for searching in the INT rulespace.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Re: Thread for basic non-CGOL questions
Does there exist a program that can simulate higher-range outer-totalistic cellular automata with more specific birth conditions than just a range, and/or can rule tables be made for such rules?
Help wanted: How can we accurately notate any 1D replicator?
Re: Thread for basic non-CGOL questions
You didn't respond to my reply on the discord server so I'll post it again here.muzik wrote:Does there exist a program that can simulate higher-range outer-totalistic cellular automata with more specific birth conditions than just a range, and/or can rule tables be made for such rules?
----
Golly cannot simulate such rules except by either using a script to evolve the pattern or emulating the rule with a multistate CA which uses two steps per generation (first step to count neighbours, second step to update states). See this Extended Neighborhood Emulator for an example which uses a radius 2 disc neighbourhood.
Brian Prentice's Java Square Cell can simulate many different types of cellular automata with range 2 neighbourhoods, including 2-state outer totalistic CA on the range 2 Moore nieghbourhood. Download the application from the link above and have a quick read of the description and usage instructions. I recommend setting the world size to 500x500 after a opening the application by clicking on the globe icon and adjusting the size parameters (default 1000x1000; you will need to do this once each time you run the app). Then save this pattern to a file and open it in the app. This will set the rule family to "Rule Table" (the default) and set the rule table options, states and neighbour weights to outer-totalistic range 2 Moore.
Code: Select all
#Rule = Rule Table
#States = 2
#Counts = 25
#SW 0,1
#NW 1,1,1,1,1
#NW 1,1,1,1,1
#NW 1,1,0,1,1
#NW 1,1,1,1,1
#NW 1,1,1,1,1
#RT 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
#RT 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
#Rows = 20
#Columns = 5
#L .A2$2.3A$2.3A2$.A9$.A$2.3A$2.3A2$2A$A
* 'N' to test new random rule
* 'R' to random fill the world
* When the simulation is stopped:
* * Space to step
* * Enter to run the simulation
* * Mouse click to set current cell to "current state"
* * Shift click to cycle "current state" and set current cell
* * Ctrl click to start and finish selection
* * Numkey +/- to zoom in / out
* * Arrow keys to pan
* When the simulation is running
* * Enter to stop simulation
* * Numkey +/- to speed up / slow down the simulation
----
Another option for exploring higher range cellular automata is Visions of Chaos. This allows exploration of many different types of CA on all kinds of neighbourhoods. Unfortunately I don't think VoC supports outer totalistic rules on large neighbourhoods, but it does support a variation of totalistic CA on arbitrary neighbourhoods up to range 15. Use Mode -> Cellular Automata -> 2D -> Large Neighbourhood Cellular Automata. If you load the .LNT file attached to this post you will see a simulation of the range 2 replicator rule. VoC has a limited range of starting conditions, if you choose Solid Square you can get a good visualisation of the replication behaviour. The rule format goes something like this:
Code: Select all
:m0,n0,r0,:m1,n1,r1,:m2,n2,r2,
----
There are bound to be many other possibilities for simulating these kinds of CA but I would say that the most useful to you would be something where you code the rule behaviour yourself. This way you can target the specific rule families you are interested in. You could do this with any number of development platforms - here are some options:
* Modify existing software: Golly, Java Square Cell, etc.
* Implement as a script in Golly - the 3D.lua script gives a good template for how to go about doing this
* Use an existing modelling environment - agent based modelling environments are well suited to this purpose and several have built in support for cellular automata, e.g. TerraME, NetLOGO, DDLab, ...
* Implement as a model in Ready. Will probably run much faster than the other options provided that Ready can use your GPU
* Implement as a shader which will run on the GPU - again, many frameworks support this, VoC has a nice Library of examples, look under Mode -> OpenGL Shading Language -> Shader Editor. The Larger than Life samples are probably a good starting point.
- Attachments
-
- R2_replicator.LNT.txt
- Range 2 replicator rule for VoC (save as .LNT file, not .txt)
- (2.35 KiB) Downloaded 514 times
The 5S project (Smallest Spaceships Supporting Specific Speeds) is now maintained by AforAmpere. The latest collection is hosted on GitHub and contains well over 1,000,000 spaceships.
Semi-active here - recovering from a severe case of LWTDS.
Semi-active here - recovering from a severe case of LWTDS.
Re: Thread for basic non-CGOL questions
Yes, apgsearch v4.63 and lifelib 2.0.17 support HROT rules with a range of up to 5.muzik wrote:Does there exist a program that can simulate higher-range outer-totalistic cellular automata with more specific birth conditions than just a range, and/or can rule tables be made for such rules?
What do you do with ill crystallographers? Take them to the mono-clinic!
Re: Thread for basic non-CGOL questions
That's still of limited usefulness, though, if there's no programs like Golly or LifeViewer that allow you to view the evolution of those patterns. Without that, there's no way to run soups to check if they produce what they are said to produce, or even if objects behave the way their apgcode says they do.calcyman wrote:Yes, apgsearch v4.63 and lifelib 2.0.17 support HROT rules with a range of up to 5.
Re: Thread for basic non-CGOL questions
It's much more useful than you make it out to be. Have a read of the lifelib documentation and you will see that aside from watching the evolution in real time, it's pretty easy to do all of those things and more.77topaz wrote:That's still of limited usefulness, though, if there's no programs like Golly or LifeViewer that allow you to view the evolution of those patterns. Without that, there's no way to run soups to check if they produce what they are said to produce, or even if objects behave the way their apgcode says they do.calcyman wrote:Yes, apgsearch v4.63 and lifelib 2.0.17 support HROT rules with a range of up to 5.
I think the hard thing here is going to be finding interesting rules where the outer totalistic characteristic is required above what LtL already offers
The 5S project (Smallest Spaceships Supporting Specific Speeds) is now maintained by AforAmpere. The latest collection is hosted on GitHub and contains well over 1,000,000 spaceships.
Semi-active here - recovering from a severe case of LWTDS.
Semi-active here - recovering from a severe case of LWTDS.
Re: Thread for basic non-CGOL questions
Oh, I see. It's still a lot more complicated to use than Golly or LifeViewer, though.wildmyron wrote:It's much more useful than you make it out to be. Have a read of the lifelib documentation and you will see that aside from watching the evolution in real time, it's pretty easy to do all of those things and more.
Muzik had some such rules (e.g. a Fredkin-like rule with all odd numbers), which is why he asked about the concept in the first place.wildmyron wrote:I think the hard thing here is going to be finding interesting rules where the outer totalistic characteristic is required above what LtL already offers
Re: Thread for basic non-CGOL questions
Hello, All.
03.10.2002 at random i found
rule = b356/s2
sum specifies the range
01110
11011
01110
exist spaceships, oscillators
Is this life and spaceships and oscillators known?
sample https://www.youtube.com/watch?v=WPXFWjM3hak
https://youtu.be/TnoQPKHWdTA
https://play.google.com/store/apps/deta ... x.fix.Life
https://youtu.be/q1wC4VVfB4M
and 3d sample exist still life, oscillators https://youtu.be/P-C5UH_bc-Y
03.10.2002 at random i found
rule = b356/s2
sum specifies the range
01110
11011
01110
exist spaceships, oscillators
Is this life and spaceships and oscillators known?
sample https://www.youtube.com/watch?v=WPXFWjM3hak
https://youtu.be/TnoQPKHWdTA
https://play.google.com/store/apps/deta ... x.fix.Life
https://youtu.be/q1wC4VVfB4M
and 3d sample exist still life, oscillators https://youtu.be/P-C5UH_bc-Y
Re: Thread for basic non-CGOL questions
Can any LTL or HROT rules support D2_+3 or D2_+4 symmetry?
Help wanted: How can we accurately notate any 1D replicator?
Re: Thread for basic non-CGOL questions
What would make those distinct from D2_+1 or D2_+2, respectively? Do you mean a 3-wide or 4-wide gutter?muzik wrote:Can any LTL or HROT rules support D2_+3 or D2_+4 symmetry?
- Hdjensofjfnen
- Posts: 1743
- Joined: March 15th, 2016, 6:41 pm
- Location: re^jθ
Re: Thread for basic non-CGOL questions
Square root bounding box growth?toroidalet wrote:What would this be called?Would it be called some arcane term like "Empty space unary counting shuttle™" or is there a simpler term for it?Code: Select all
x = 13, y = 5, rule = B3-y4q5a/S23-e 5bo4b2o$5bobobo2bo$b2o2b2o3b2o$o2bo$b2o!
Code: Select all
x = 5, y = 9, rule = B3-jqr/S01c2-in3
3bo$4bo$o2bo$2o2$2o$o2bo$4bo$3bo!
Code: Select all
x = 7, y = 5, rule = B3/S2-i3-y4i
4b3o$6bo$o3b3o$2o$bo!
Re: Thread for basic non-CGOL questions
Not sure where to put this question. Also english is not my native.
Take any oscillator. Choose any generation (we need at least one). Clone it n times on infinite grid with two conditions: 1) each copy shifted by the same distance from previous (we need at least one way); 2) for any natural n those groups of copies is also oscillators with P_k(n) (polynomial) periodicity. If it satisfies given conditinions we may define it as absolute oscillator.
Is there any known examples? If yes, so for which rules? Is there a way to prove or disprove existence of such oscillators for chosen rule?
Take any oscillator. Choose any generation (we need at least one). Clone it n times on infinite grid with two conditions: 1) each copy shifted by the same distance from previous (we need at least one way); 2) for any natural n those groups of copies is also oscillators with P_k(n) (polynomial) periodicity. If it satisfies given conditinions we may define it as absolute oscillator.
Is there any known examples? If yes, so for which rules? Is there a way to prove or disprove existence of such oscillators for chosen rule?
Re: Thread for basic non-CGOL questions
I don't quite understand, are you looking for something like this pattern due to David Greene?:kthxbye wrote:Not sure where to put this question. Also english is not my native.
Take any oscillator. Choose any generation (we need at least one). Clone it n times on infinite grid with two conditions: 1) each copy shifted by the same distance from previous (we need at least one way); 2) for any natural n those groups of copies is also oscillators with P_k(n) (polynomial) periodicity. If it satisfies given conditinions we may define it as absolute oscillator.
Is there any known examples? If yes, so for which rules? Is there a way to prove or disprove existence of such oscillators for chosen rule?
Code: Select all
x = 123, y = 59, rule = 03467/25/6
DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.CBA5.ABC5.CBA5.ABC5.CBA5.ABC
5.CBA5.ABC$CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.BCB
5.BCB5.BCB5.BCB5.BCB$ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABCE4.CB
A5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA$66.E.E13.E.E13.E.E13.E.E$4.DCA5.AC
D5.DCA5.ACD5.DCA5.ACD5.DCA12.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$4.
CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC13.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB
$4.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD13.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CB
A5.ABCE$70.E.E13.E.E13.E.E13.E.E$ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.D
CA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$CDC5.CDC5.CDC5.CDC5.CD
C5.CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$DCA5.ACD5.DC
A5.ACD5.DCA5.ACD5.DCA5.ACD5.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABC
$74.E.E13.E.E13.E.E$4.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD13.ABC4.ECBA5.
ABC4.ECBA5.ABC4.ECBA5.ABC$4.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC13.BCB5.
BCB5.BCB5.BCB5.BCB5.BCB5.BCB$4.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA13.CB
A5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA$78.E.E13.E.E13.E.E$DCA5.ACD5.DCA5.
ACD5.DCA5.ACD5.DCA5.ACD5.CBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC$CD
C5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.B
CB5.BCB$ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABCE4.CBA5.ABCE4.CBA
5.ABCE4.CBA5.ABCE4.CBA$66.E.E13.E.E13.E.E13.E.E$4.DCA5.ACD5.DCA5.ACD
5.DCA5.ACD5.DCA12.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$4.CDC5.CDC5.C
DC5.CDC5.CDC5.CDC5.CDC13.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$4.ACD5.DCA
5.ACD5.DCA5.ACD5.DCA5.ACD13.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE$70.
E.E13.E.E13.E.E13.E.E$ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABC4.EC
BA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC
5.CDC5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$DCA5.ACD5.DCA5.ACD5.DCA
5.ACD5.DCA5.ACD5.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABC$74.E.E13.E
.E13.E.E$4.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD13.ABC4.ECBA5.ABC4.ECBA5.
ABC4.ECBA5.ABC$4.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC13.BCB5.BCB5.BCB5.B
CB5.BCB5.BCB5.BCB$4.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA13.CBA5.ABCE4.CB
A5.ABCE4.CBA5.ABCE4.CBA$78.E.E13.E.E13.E.E$DCA5.ACD5.DCA5.ACD5.DCA5.A
CD5.DCA5.ACD5.CBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC$CDC5.CDC5.CDC
5.CDC5.CDC5.CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$ACD
5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA
5.ABCE4.CBA$66.E.E13.E.E13.E.E13.E.E$4.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.
DCA12.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$4.CDC5.CDC5.CDC5.CDC5.CDC
5.CDC5.CDC13.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$4.ACD5.DCA5.ACD5.DCA5.
ACD5.DCA5.ACD13.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE$70.E.E13.E.E13.
E.E13.E.E$ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABC4.ECBA5.ABC4.ECB
A5.ABC4.ECBA5.ABC4.ECBA$CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.BCB5.
BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.
ACD5.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABC$74.E.E13.E.E13.E.E$4.A
CD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD13.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA5.A
BC$4.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC13.BCB5.BCB5.BCB5.BCB5.BCB5.BCB
5.BCB$4.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA13.CBA5.ABCE4.CBA5.ABCE4.CBA
5.ABCE4.CBA$78.E.E13.E.E13.E.E$DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD
5.CBA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA5.ABC$CDC5.CDC5.CDC5.CDC5.CDC5.
CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$ACD5.DCA5.ACD5.
DCA5.ACD5.DCA5.ACD5.DCA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA$
66.E.E13.E.E13.E.E13.E.E$4.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA12.ECBA5.
ABC4.ECBA5.ABC4.ECBA5.ABC4.ECBA$4.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC
13.BCB5.BCB5.BCB5.BCB5.BCB5.BCB5.BCB$4.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.
ACD13.ABCE4.CBA5.ABCE4.CBA5.ABCE4.CBA5.ABCE$70.E.E13.E.E13.E.E13.E.E$
ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ABC4.ECBA5.ABC4.ECBA5.ABC4.EC
BA5.ABC4.ECBA$CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.CDC5.BCB5.BCB5.BCB5.
BCB5.BCB5.BCB5.BCB5.BCB$DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.DCA5.ACD5.CBA5.
ABC5.CBA5.ABC5.CBA5.ABC5.CBA5.ABC!
[[ STOP 429 ]]
Re: Thread for basic non-CGOL questions
First of all, thank you for answer! I also have problems with understanding (exactly how this pattern works). But, yes, it include something like what I am looking for. Let me show:danny wrote:I don't quite understand, are you looking for something like this pattern due to David Greene?:
Code: Select all
x = 23, y = 47, rule = 03467/25/6
DCA$CDC$ACD2$4.DCA$4.CDC$4.ACD14$DCA5.DCA$CDC5.CDC$ACD5.ACD2$4.DCA5.D
CA$4.CDC5.CDC$4.ACD5.ACD14$DCA5.DCA5.DCA$CDC5.CDC5.CDC$ACD5.ACD5.ACD
2$4.DCA5.DCA5.DCA$4.CDC5.CDC5.CDC$4.ACD5.ACD5.ACD!
Re: Thread for basic non-CGOL questions
Ah, so something like this:
Forgot who discovered it though.
Code: Select all
x = 15, y = 1, rule = B2i36i/S02-in3
obobobobobobobo!
Re: Thread for basic non-CGOL questions
Are there any spaceships an some nontotalistic rule that are slower than the c/5648 one in gems?
Code: Select all
x = 12, y = 14, rule = B3457/S4568
5b2o$3bo4bo$3b2o2b2o$b3o4b3o$b3o4b3o$2ob6ob2o$3ob4ob3o$ob3o2b3obo$2ob6ob2o$ob
obo2bobobo$2b2ob2ob2o$2b8o$4b4o$4bo2bo!
not active here but active on discord
-
- Posts: 1334
- Joined: July 1st, 2016, 3:58 pm
Re: Thread for basic non-CGOL questions
Yeah, pretty much any known adjustable ship family can get speeds slower than that.
I manage the 5S project, which collects all known spaceship speeds in Isotropic Non-totalistic rules. I also wrote EPE, a tool for searching in the INT rulespace.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Things to work on:
- Find (7,1)c/8 and 9c/10 ships in non-B0 INT.
- EPE improvements.
Re: Thread for basic non-CGOL questions
Oh right.AforAmpere wrote:Yeah, pretty much any known adjustable ship family can get speeds slower than that.
I guess, are there any nonadjustable ones known?
not active here but active on discord
Re: Thread for basic non-CGOL questions
Does this c/40368 count?
Dean Hickerson wrote: This one is even slower:
Code: Select all
# Speed 1/40368 orthogonal spaceship x = 78, y = 81, rule = R39,C0,M1,S2174..3710,B1884..3748,NM 43bo$47bo$29bo17bobo$26b2o20b4o$24b3o22b5o$22b4o10b5o9b6o$21b4o5b16o5b 6o$17bob6o3b21o3b6o$16bob6o2b25o2b7o$15b8ob28ob8o$14b48o$13b50o$12b52o $11b54o$10b56o$9b58o$8b60o$7b62o$6b64o$5b66o$4bob65o$3bob67o$4b69o$4b 69o$bob70o$3b72o$b4o2b62o2b3o$2b2o2b64o2b4o$3o3b64o3b2o$bo3b66o3b3o$o 4b66o4bo$4b68o$4b68o4b2o$4b68o$3b69o$3b69o$3b69o$3b70o$3b70o$3b70o$3b 70o$3b70o$3b70o$3b70o$3b69o$3b69o$3b69o$4b68o$4b68o4b2o$4b68o$o4b66o4b o$bo3b66o3b3o$3o3b64o3b2o$2b2o2b64o2b4o$b4o2b62o2b3o$3b72o$bob70o$4b 69o$4b69o$3bob67o$4bob65o$5b66o$6b64o$7b62o$8b60o$9b58o$10b56o$11b54o$ 12b52o$13b50o$14b48o$15b8ob28ob8o$16bob6o2b25o2b7o$17bob6o3b21o3b6o$ 21b4o5b16o5b6o$22b4o10b5o9b6o$24b3o22b5o$26b2o20b4o$29bo17bobo$47bo$ 43bo!
Help wanted: How can we accurately notate any 1D replicator?
Re: Thread for basic non-CGOL questions
Well, I was looking for nontotalistic, but I guess that works too.muzik wrote:Does this c/40368 count?Dean Hickerson wrote: This one is even slower:
Code: Select all
# Speed 1/40368 orthogonal spaceship x = 78, y = 81, rule = R39,C0,M1,S2174..3710,B1884..3748,NM 43bo$47bo$29bo17bobo$26b2o20b4o$24b3o22b5o$22b4o10b5o9b6o$21b4o5b16o5b 6o$17bob6o3b21o3b6o$16bob6o2b25o2b7o$15b8ob28ob8o$14b48o$13b50o$12b52o $11b54o$10b56o$9b58o$8b60o$7b62o$6b64o$5b66o$4bob65o$3bob67o$4b69o$4b 69o$bob70o$3b72o$b4o2b62o2b3o$2b2o2b64o2b4o$3o3b64o3b2o$bo3b66o3b3o$o 4b66o4bo$4b68o$4b68o4b2o$4b68o$3b69o$3b69o$3b69o$3b70o$3b70o$3b70o$3b 70o$3b70o$3b70o$3b70o$3b69o$3b69o$3b69o$4b68o$4b68o4b2o$4b68o$o4b66o4b o$bo3b66o3b3o$3o3b64o3b2o$2b2o2b64o2b4o$b4o2b62o2b3o$3b72o$bob70o$4b 69o$4b69o$3bob67o$4bob65o$5b66o$6b64o$7b62o$8b60o$9b58o$10b56o$11b54o$ 12b52o$13b50o$14b48o$15b8ob28ob8o$16bob6o2b25o2b7o$17bob6o3b21o3b6o$ 21b4o5b16o5b6o$22b4o10b5o9b6o$24b3o22b5o$26b2o20b4o$29bo17bobo$47bo$ 43bo!
not active here but active on discord