Moosey wrote:Has anyone thought to look for ships like the copperhead or loafer recently--small+slow ships nobody thought to look for?
Something like a c/17 or something else that would be moderately slow, but slower than any known small-scale ships?
dvgrn wrote:muzik from a few years ago
Moosey wrote:Would it be plausible, though, to run a quick search for small ships across many speeds and eliminate all within a slightly-larger-than-a-copperhead-sized bounding box in a reasonable amount of time?
x = 20, y = 51, rule = LifeHistory
9.2A$9.2A9$9.D.D$9.D2.D$8.D3.D$9.D2.D5.A$9.3D5.A.A$18.A5$15.2A$15.A.A
$17.A$8.2D2.D4.2A$9.3D$10.D13$4.2A$3.4A2$2.6A$3.4A2$2.2A2.2A$2A.A2.A.
2A$3.A2.A3$4.2A$4.2A!
x = 20, y = 56, rule = LifeHistory
6.3C$6.C$5.3C5.2A.A$13.A.2A2$9.2B$9.2B9$9.D.D$9.D2.D$8.D3.D$9.D2.D5.A
$9.3D5.A.A$18.A5$15.2A$15.A.A$17.A$8.2D2.D4.2A$9.3D$10.D13$4.2A$3.4A
2$2.6A$3.4A2$2.2A2.2A$2A.A2.A.2A$3.A2.A3$4.2A$4.2A!
x = 66, y = 70, rule = LifeHistory
4.2A.A$4.A.2A2$5.5A$2A2.A4.A20.2A$A2.A2.A23.A$.A.A.2A21.A.A$2A.A5.A
18.2A$3.A4.A.A$3.2A2.A2.A$8.2A$39.2A$39.A$37.A.A$37.2A13.3C$52.C$19.
2A30.3C5.2A.A$19.2A38.A.2A2$55.2B$55.2B9$29.A25.D.D$28.A.A24.D2.D$28.
A.A23.D3.D$29.A25.D2.D5.A$55.3D5.A.A$64.A5$61.2A$61.A.A$63.A$54.2D2.D
4.2A$55.3D$56.D13$50.2A$49.4A2$48.6A$49.4A2$48.2A2.2A$46.2A.A2.A.2A$
49.A2.A3$50.2A$50.2A!
Moosey wrote:What is the smallest CC reflector?
#C syringe + HNE5T-4
x = 55, y = 33, rule = B3/S23
bo$2bo$3o$40bo$40b3o$43bo$30b2o10b2o$31bo$31bobo19b2o$21bo10b2o19bo$
19b3o29bobo$18bo32b2o$18b2o$3b2o$4bo$4bob2o43b2o$5bo2bo42bobo$6b2o45bo
$21b2o24b2o4b2o$21b2o24bobo$49bo$49b2o2$30bo3b2o$29bobo3bo$28bobo3bo$
24b2obobo3bo$24b2obo2b4obo$28bobo3bobo$24b2ob2o2bo2bobo$25bobo2b2o3bo$
13b2o10bobo$13b2o11bo!
#C syringe + HSE18T9
x = 55, y = 37, rule = LifeHistory
27.A$26.A.A4.2A$26.A.A3.B2AB$25.2A.2A2.3B7.A$25.A2.B3.2B6.3A$26.AB2AB
.3B4.A$24.A.A.2A5B4.2A$24.2A4.7B.3B$31.8B$3.A26.10B$4.A25.5B2A2B$2.3A
B23.6B2A2B$3.4B22.9B.B3.2B$4.4B10.A10.8B.3B.4B$5.4B7.3A11.17B$6.4B5.A
14.17B$7.4B4.2A14.17B$2A6.9B14.16B$.A7.6B14.18B$.A.2A5.6B3.B2.2B2.21B
$2.A2.A4.19BD18B$3.2AB3.6BD13BDBD4B.7B.4B$4.9BDBD2B2A9B3D4B.7B2.4B$5.
9B2D2B2A11BD4B.7B3.4B$6.29B3.5B5.4B$6.17B.B13.7B4.4B$7.15B15.2B4.2A5.
4B$7.15B15.2AB3.A7.4B$8.13B5.A3.2A.2A.A.A5.3A5.3B$10.13B2.A.A3.A.A.2A
.A.A5.A6.2B$9.8B4.2A.A.A3.A8.2A13.B$9.6B6.2ABA4.A$9.5B8.B2.5A.A$9.B.B
5.2A.A.2A.A4.A.A$10.3B4.A.2A.A2.A.2A2.A$9.B2AB11.2A.A.2A$10.2A!
#C syringe + HSE22T-8
x = 53, y = 29, rule = LifeHistory
37.A$3.A33.3A$4.A23.A11.A$2.3AB22.3A8.2A5.4B$3.4B24.A7.11B$4.4B10.A
11.2A3.B5.11B$5.4B7.3A11.8B2.11B2A$6.4B5.A16.19B2A$7.4B4.2A15.20B$2A
6.9B14.20B$.A7.6B14.21B$.A.2A5.6B3.B2.2B2.25B$2.A2.A4.19BD14B4.4B$3.
2AB3.6BD13BDBD4B.6B6.4B$4.9BDBD2B2A9B3D4B2.B.5B5.3B$5.9B2D2B2A11BD4B
7.2A6.2B$6.29B8.A8.B$6.17B.B.2B16.3A$7.15B4.B19.A$7.15B$8.13B5.A3.2A$
10.13B2.A.A3.A$9.8B4.2A.A.A3.A$9.6B6.2ABA4.A$9.5B8.B2.5A.A$9.B.B5.2A.
A.2A.A4.A.A$10.3B4.A.2A.A2.A.2A2.A$9.B2AB11.2A.A.2A$10.2A!
Needless to say, these copperhead-to-Gs will have even longer repeat times than existing ones. Especially if I use a B-not-a-conduit which just cleans up the B junk...
testitemqlstudop wrote:How do I make a History rule of a non-totalistic rule, like the ones displayed in LV (B2c3aei4ajnr5acn/S2-ci3-ck4in5jkq6c7cHistory)
Gustone wrote:What are the smallest reflectors ... by bounding box and regardless of period?
x = 28, y = 25, rule = LifeHistory
24.2A$8.BABA12.A$9.B2AB5.B2.BA.A$10.A3B3.3B.B2A$11.4B.2BA3B$4.B7.4B2A
B2AB$4.2B7.4BA2BAB$4.3B7.4B2AB$4.4B5.A7B$5.4B3.A7B$6.4B.B3A2.3B$7.7B
3.3B$8.5B6.3B$8.6B5.4AB2.B$6.3B2A4B3.A7B2A$2.2A2.2BA2BA4B2.A3B2A2B2A$
.BABA4BABA3B4.A2.2A3B$2.B3A3.BA3B10.3B$2.2B2A5.5B$.2A2B9.2A$.3AB9.A$
4B11.3A$4B13.A$2B2AB$2.2A!
dvgrn wrote:testitemqlstudop wrote:How do I make a History rule of a non-totalistic rule, like the ones displayed in LV (B2c3aei4ajnr5acn/S2-ci3-ck4in5jkq6c7cHistory)
This is a case where a rule-generator script has been needed for a long time, but I don't think anyone ever wrote one. At least I hope not, because if someone did then I just wasted an hour of fiddly script-writing work.
Version 1.0 of a History-rule-making script is checked in at isotropic-history-rule-gen.py.
testitemqlstudop wrote:Can I have one that also includes the standard LifeHistory red cells?
Gustone wrote:Is there an official name for this spark?Code: Select allx = 3, y = 4, rule = b3/s23
bo$3o$3o$bo!
x = 4, y = 2, rule = B3/S23
4o$o2bo!
x = 1, y = 6, rule = B3/S23
o$o$o$o$o$o!
GUYTU6J wrote:I download the software Ready under gollygang umbrella, and found it is capable of generating finite Penrose tiling by subdivision. Can I modify anything so that it can be applied to custom subdivision rules and effectively leading to other aperiodic 2d tilings?
<UnstructuredGrid>
<Piece NumberOfPoints="3126" NumberOfCells="3010" >
<PointData>
</PointData>
<CellData>
<DataArray type="Float32" Name="a" format="appended" RangeMin="0" RangeMax="2" offset="0" />
</CellData>
<Points>
<DataArray type="Float32" Name="Points" NumberOfComponents="3" format="appended" RangeMin="0" RangeMax="1.0000004786" offset="84" />
</Points>
<Cells>
<DataArray type="Int64" Name="connectivity" format="appended" RangeMin="" RangeMax="" offset="14892" />
<DataArray type="Int64" Name="offsets" format="appended" RangeMin="" RangeMax="" offset="37152" />
<DataArray type="UInt8" Name="types" format="appended" RangeMin="" RangeMax="" offset="42492" />
</Cells>
</Piece>
</UnstructuredGrid>
<AppendedData encoding="base64">
{blah blah blah blah}
/// Make a planar Penrose tiling, using either rhombi (type=0) or darts and kites (type=1).
void MeshGenerators::GetPenroseTiling(int n_subdivisions,int type,vtkUnstructuredGrid* mesh,int n_chems,int data_type)
{
// Many thanks to Jeff Preshing: http://preshing.com/20110831/penrose-tiling-explained
const int RHOMBI = 0;
const int DARTS_AND_KITES = 1;
// we keep a list of the 'red' and 'blue' Robinson triangles and use 'deflation' (decomposition)
vector<Tri> red_tris[2],blue_tris[2]; // each list has two buffers
int iCurrentBuffer = 0;
vtkSmartPointer<vtkPoints> pts = vtkSmartPointer<vtkPoints>::New();
TPairIndex edge_splits; // given a pair of point indices, what is the index of the point made by splitting that edge?
// start with 10 red triangles in a wheel, to get a nice circular shape (with 5-fold rotational symmetry)
// (any correctly-tiled starting pattern will work too)
const int NT = 10;
const double angle_step = 2.0 * 3.1415926535 / NT;
const double goldenRatio = (1.0 + sqrt(5.0)) / 2.0;
const double scale = pow( goldenRatio, n_subdivisions );
pts->InsertNextPoint(0,0,0);
for(int i=0;i<NT;i++)
{
pts->InsertNextPoint(scale*cos(angle_step*i),scale*sin(angle_step*i),0);
int i1 = (i + i%2) % NT;
int i2 = (i + 1 - i%2) % NT;
double angle1 = angle_step * i1;
double angle2 = angle_step * i2;
double p1[3] = { scale*cos(angle1), scale*sin(angle1), 0 };
double p2[3] = { scale*cos(angle2), scale*sin(angle2), 0 };
switch(type) {
default:
case RHOMBI:
red_tris[iCurrentBuffer].push_back(Tri(0,0,0,p1[0],p1[1],1+i1,p2[0],p2[1],1+i2));
break;
case DARTS_AND_KITES:
red_tris[iCurrentBuffer].push_back(Tri(p1[0],p1[1],1+i1,0,0,0,p2[0],p2[1],1+i2));
break;
}
}
// subdivide
double px,py,qx,qy,rx,ry;
for(int i=0;i<n_subdivisions;i++)
{
int iTargetBuffer = 1-iCurrentBuffer;
red_tris[iTargetBuffer].clear();
blue_tris[iTargetBuffer].clear();
// subdivide the red triangles
for(vector<Tri>::const_iterator it = red_tris[iCurrentBuffer].begin();it!=red_tris[iCurrentBuffer].end();it++)
{
switch(type)
{
default:
case RHOMBI:
{
int iP = SplitEdge(*it,0,1,px,py,edge_splits,pts); // split A and B to get a new point P
red_tris[iTargetBuffer].push_back(Tri(it->p[2][0],it->p[2][1],it->index[2],px,py,iP,it->p[1][0],it->p[1][1],it->index[1]));
blue_tris[iTargetBuffer].push_back(Tri(px,py,iP,it->p[2][0],it->p[2][1],it->index[2],it->p[0][0],it->p[0][1],it->index[0]));
break;
}
case DARTS_AND_KITES:
{
int iQ = SplitEdge(*it,0,1,qx,qy,edge_splits,pts); // split A and B to get point Q
int iR = SplitEdge(*it,1,2,rx,ry,edge_splits,pts); // split B and C to get point R
blue_tris[iTargetBuffer].push_back(Tri(rx,ry,iR,qx,qy,iQ,it->p[1][0],it->p[1][1],it->index[1]));
red_tris[iTargetBuffer].push_back(Tri(qx,qy,iQ,it->p[0][0],it->p[0][1],it->index[0],rx,ry,iR));
red_tris[iTargetBuffer].push_back(Tri(it->p[2][0],it->p[2][1],it->index[2],it->p[0][0],it->p[0][1],it->index[0],rx,ry,iR));
break;
}
}
}
// subdivide the blue triangles
for(vector<Tri>::const_iterator it = blue_tris[iCurrentBuffer].begin();it!=blue_tris[iCurrentBuffer].end();it++)
{
switch(type)
{
default:
case RHOMBI:
{
int iQ = SplitEdge(*it,1,0,qx,qy,edge_splits,pts); // split B and A to get point Q
int iR = SplitEdge(*it,1,2,rx,ry,edge_splits,pts); // split B and C to get point R
red_tris[iTargetBuffer].push_back(Tri(rx,ry,iR,qx,qy,iQ,it->p[0][0],it->p[0][1],it->index[0]));
blue_tris[iTargetBuffer].push_back(Tri(rx,ry,iR,it->p[2][0],it->p[2][1],it->index[2],it->p[0][0],it->p[0][1],it->index[0]));
blue_tris[iTargetBuffer].push_back(Tri(qx,qy,iQ,rx,ry,iR,it->p[1][0],it->p[1][1],it->index[1]));
break;
}
case DARTS_AND_KITES:
{
int iP = SplitEdge(*it,2,0,px,py,edge_splits,pts); // split C and A to get point P
blue_tris[iTargetBuffer].push_back(Tri(it->p[1][0],it->p[1][1],it->index[1],px,py,iP,it->p[0][0],it->p[0][1],it->index[0]));
red_tris[iTargetBuffer].push_back(Tri(px,py,iP,it->p[2][0],it->p[2][1],it->index[2],it->p[1][0],it->p[1][1],it->index[1]));
break;
}
}
}
iCurrentBuffer = iTargetBuffer;
}
// merge triangles that have abutting open edges into quads
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
{
vector<Tri> all_tris(red_tris[iCurrentBuffer]);
all_tris.insert(all_tris.end(),blue_tris[iCurrentBuffer].begin(),blue_tris[iCurrentBuffer].end());
TPairIndex half_quads; // for each open edge, what is the index of its triangle?
TPairIndex::const_iterator found;
for(int iTri = 0; iTri<(int)all_tris.size(); iTri++)
{
// is this the other half of a triangle we've seen previously?
pair<int,int> edge(all_tris[iTri].index[1],all_tris[iTri].index[2]);
found = half_quads.find(edge);
if(found!=half_quads.end())
{
// output a quad (no need to store the triangle)
cells->InsertNextCell(4);
cells->InsertCellPoint(all_tris[iTri].index[0]);
cells->InsertCellPoint(all_tris[iTri].index[1]);
cells->InsertCellPoint(all_tris[found->second].index[0]);
cells->InsertCellPoint(all_tris[iTri].index[2]);
}
else
{
// this triangle has not yet found its other half so store it for later
half_quads[edge] = iTri;
}
}
}
mesh->SetPoints(pts);
mesh->SetCells(VTK_POLYGON,cells);
// allocate the chemicals arrays
for(int iChem=0;iChem<n_chems;iChem++)
{
vtkSmartPointer<vtkDataArray> scalars = vtkSmartPointer<vtkDataArray>::Take( vtkDataArray::CreateDataArray( data_type ) );
scalars->SetNumberOfComponents(1);
scalars->SetNumberOfTuples(mesh->GetNumberOfCells());
scalars->SetName(GetChemicalName(iChem).c_str());
scalars->FillComponent(0,0.0f);
mesh->GetCellData()->AddArray(scalars);
}
}
import golly as g
import math
import svgwrite
from svgwrite import cm, mm
def goldpt(coord1, coord2):
x1, y1 = coord1; x2, y2 = coord2
x3, y3 = x1+golden*(x2-x1), y1+golden*(y2-y1)
return (x3, y3)
level = 12
dwg = svgwrite.Drawing(filename='c:/your/path/here/goldenbee.svg', debug=True)
scale = 500.0
margin = scale/10
golden = math.sqrt(5)/2.0-0.5
top = 0
left = 0
bottom=scale
right = math.sqrt(golden)*scale
ledge = bottom - golden*(bottom-top)
vert = left+golden*(right-left)
coord1 = (left,top)
coord2 = (left,bottom)
coord3 = (right,bottom)
coord4 = (right, ledge)
coord5 = (vert, ledge)
coord6 = (vert, top)
dwg.viewbox(left-margin, top-margin, right+margin, bottom+margin)
dwg.add(dwg.g(id='demo'))
tilelist = [([coord1, coord2, coord3, coord4, coord5, coord6], 1, 0)]
while level>0:
level -= 1
newtilelist=[]
for tile in tilelist:
coord1, coord2, coord3, coord4, coord5, coord6 = tile[0]
coord7 = goldpt(coord3, coord1)
coord9 = goldpt(coord1, coord2)
coordZ = goldpt(coord3, coord4)
coord8 = goldpt(coordZ, coord9)
othercolor = tile[2]+1 -(3 if tile[2]==2 else 0)
newtilelist.append(([coord2, coord3, coord4, coord7, coord8, coord9],tile[1]+1, tile[2]))
newtilelist.append(([coord9, coord1, coord6, coord5, coord7, coord8], tile[1]+2, othercolor))
tilelist=newtilelist[:]
for tile in tilelist[::-1]:
if tile[2]==0: s="rgb(90%,90%,100%)"
elif tile[2]==1: s="rgb(70%,90%,50%)"
else: s="rgb(100%,80%,90%)"
tiles = dwg.add(dwg.g(stroke='green', fill=s, stroke_width=10.0/tile[1]))
tiles.add(dwg.polygon(tile[0]))
dwg.save()
g.show("Wrote output to goldenbee.svg.")
pip install svgwrite
x = 9, y = 7, rule = B2cn3c/S012345678
b7o$bo5bo$2obobob2o2$bobobobo$bo5bo$b7o!
x = 15, y = 15, rule = B2cn3-kry/S0234i
10bo$5bo2b5o$2bo4bo5bo$4bobobo2bobo$3b2ob2o5b2o$bo11bo$3b2obobo2bobo$
2bobo5bobo$bobo2bobob2o$bo11bo$2o5b2ob2o$bobo2bobobo$bo5bo4bo$2b5o2bo$
4bo!
toroidalet wrote:Are there any septuple+ pseudo still lives (not in life)?
Here is an example of a sextuple pseudo still life, to prove it's possible...
On July 15, 2001, Gabriel Nivasch wrote:Message #1: Blocking crossing
Here is a still life construction that Matthew Cook calls a "blocking
crossing":
..................jj.......jj......
..................jj.......jj......
...................................
..................jjjj.j.jjjj......
..............jj.j..j.jjj.j..j.jj..
..............j.jj...........jj.j..
.....................hh.ii.........
...............ff.h...h.i...i.ee...
..............f.f.hhhh...iiii.e.e..
..............f..................e.
............fff.....hh...ii.......e
...........f.......h.h...i.i.....ee
............fff....h.......i....e..
..............f...hh.......ii...e..
...............ff.............ee...
................f.gg...g...gg.e....
...............f..g.g.g.g.g.g..e...
...............ff...g.g.g.g...ee...
............ff.f...g.g...gg....e.ee
............f..f...g...........e.ee
......ff.ff.f..ff.gg.........ee....
......f.ff.f...........e.ee.e......
....ff.........dd.ee..e.ee.ee......
ff.f...........d...e..e............
ff.f....dd...d.d...e.ee............
...ff...d.d.d.d...ee...............
...f..d.d.d.d.d.d..e...............
....f.dd...d...dd.e................
...ff.............ee...............
..f...cc.......bb...e..............
..f....c.......b....eee............
ff.....c.c...b.b.......e...........
f.......cc...bb.....eee............
.f..................e..............
..f.f.cccc...bbbb.e.e..............
...ff.c...c.b...b.ee...............
.........cc.bb.....................
..a.aa...........aa.a..............
..aa.a..a.aaa.a..a.aa..............
......aaaa.a.aaaa..................
...................................
......aa.......aa..................
......aa.......aa..................
If we want to decompose it into sets that are independently stable, we find
that:
1.- a requires b or c.
2.- If a and b are in the same set, they require e and d.
3.- If a and c are in the same set, they require f and d.
4.- Therefore: a requires d and {e or f}.
5.- Similarly, j requires g and {e or f}.
6.- Of the 4 pieces d, e, f, and g, a single set cannot contain exactly 3 of
them.
It follows that, if the pattern is to be decomposed at all, there are only two
ways of doing it: Either a goes together with e, and j with f; or a goes
together with f, and j with e. (In the first case, c and i have to belong to a
third set. In the second case, b and h have to belong to a third set.)
If we think of the imaginary lines that serve as "frontiers" between the
different sets, then this pattern allows two possibilities: either a line going
diagonally down from NW to SE, or a line going diagonally up from SW to NE.
That's why this pattern is a "blocking crossing".
In his paper "Still Life Theory"
(http://www.paradise.caltech.edu/~cook/W ... index.html), Cook gives a
diagram of the structure of a blocking crossing (p. 17), although he doesn't
show an explicit pattern. This pattern has a simpler structure than Cook's
diagram.
In his paper, Cook uses blocking crossings in a method of constructing a still
life whose decomposition is equivalent to solving a given CNF expression. It
follows that the problem decomposing a still life is NP-complete.
The above pattern has 290 cells. It can probably be improved, since I didn't
spend an enormous amount of time tinkering with it.
On July 16, 2001, Gabriel Nivasch wrote:Message #2: Blocking crossing (2)
I wrote:
> The above pattern has 290 cells.
It can be brought down to 284 cells by replacing the two instances of
o..... o....
oo.... oo...
..o... ..o..
..ooo. ..o..
.....o ...oo
..ooo. ....o
..o... ...o.
o.o... o.o..
oo.... by oo... .
In Matthew's construction, there are many times when a border-line intersects
another one twice, using two blocking crossings, in order to allow using only
one of them, like in this diagram:
-- --
\ /\ /
x x
/ \/ \
-- --
Instead of two blocking crossings, we can use a simpler arrangement that
produces the same effect:
..........aa.......
.........a.a.......
....bb..a...aa.....
....b..a......a.aa.
.....b.aa.....aa.a.
....bb.............
bb.b...xx....x.dd..
bb.b....x..xxx.d.d.
...bb...x.x......d.
...b..x.x.xx....d..
....b.xx........dd.
...bb.............d
....b.yy........dd.
...b..y.y.yy....d..
...bb...y.y......d.
bb.b....y..yyy.d.d.
bb.b...yy....y.dd..
....bb.............
.....b.cc.....cc.c.
....b..c......c.cc.
....bb..c...cc.....
.........c.c.......
..........cc.......
Piece b requires x or y. If b and x go together, they need a and d. If b and y
go together, they need c and d. Therefore, there are two possibilities: Either
b, a, and d go together and are separated from a; or b, c, and d go together
and are separated from c.
So instead of using two blocking crossings, we use half of one.
This arrangement could be called a "blocking parallel pair".
Users browsing this forum: No registered users and 2 guests