Rules for Sexyloop
FeepingCreature
has anybody here managed to discover or reverse-engineer the ruleset used for Sexyloops (a form of langton loop modified for quasi-sexual reproduction).
The PDF available on https://uhra.herts.ac.uk/dspace/handle/2299/1735 and also http://ieeexplore.ieee.org/iel5/4218857/4218858/04218878.pdf?arnumber=4218878 if you feel the pressing need to pay $30 for it, doesn't mention the actual rules used. Google has also come up blank.
Any ideas?
Tim Tyler
My impression: my HAL was doing most of this stuff > 10 years ago:
HAL doesn't have sheathed loops - which means more states-per-cell - but
tends to lead to more interesting dynamics when things bang together.
I wouldn't say that HAL exhibited sex: but that's because I have an
elevated and lofy conception of what sex means, or should mean:
http://alife.co.uk/essays/sex_is_not_a_disease/
--
__________
|im |yler http://timtyler.org/ t...@tt1lock.org Remove lock to reply.
FeepingCreature
While it certainly sounds interesting (I haven't been able to get it to run yet), the concept of separating it into different layers makes it just a tad hard to reproduce compared to langton's loops' eight states in total. :)
Is there any documentation or tutorials available on using layers in CAs? I haven't seen the approach before.
More to the point, do you have any documentation on the ruleset used for HAL? It's no fun if you can't reproduce it :p
Jean H.
>to run yet), the concept of separating it into different layers makes >it
>just a tad hard to reproduce compared to langton's loops' eight states
>in total. :)
>
> Is there any documentation or tutorials available on using layers in
> CAs? I haven't seen the approach before.
Hi,
I haven't looked into HAL or the other link, so forgive me if I am way
off. I do however program CA for land-use change simulations.
The concept of layers is not that difficult and can be used efficiently,
especially if you have several CPU on your computer. For example, you
can have a layer for each cell state. For each time step, each layer
evolves independently (= the transition rules are applied everywhere
through space).Then, since a cell can have only 1 main state, you need
to decide which layer to use. In my case, I have 2 layers for each
land-use state: 1 to hold the new land-use state (so a change from
Forest to Urban, or from Forest to Agriculture, or from Forest to X),
and another one holding, basically, the probability of that change.
Then, according to external and internal constraints, I select the layer
having the best probability of change and apply it to the main land-use
map (or if you prefer, the state layer).
Similarly, driving factors (i.e. a map of feature that influence the
land-use change, such as the distance to a main road, to downtown etc)
are stored in layers. At simulation time, the CA must look into these
layers and apply or not a transition rule base on the value. You can
easily replace a driving factor layer by another cell-state layer...
If you want more details about all of these, you can read the
methodology of my thesis
http://www.ucalgary.ca/engo_webdocs/DM/08.20265.JGHasbani.pdf
On a test, I developed once a "temporal game of life", where each cell
had 1) a state and 2) an age. Transition rules where based both on the
state and the age (a baby or elder can not give life, a baby can not die
of overcrowding but an elder can etc). Therefore, 2 layers where running
in parallel, one feeding information to the other. Implementation is
fairly easy... just have 2 arrays instead of 1, and update both arrays
at each time step (just be careful which one, if any, you must update first)
Jean
FeepingCreature
> On a test, I developed once a "temporal game of life", where each cell
> had 1) a state and 2) an age. Transition rules where based both on the
> state and the age (a baby or elder can not give life, a baby can not die
> of overcrowding but an elder can etc). Therefore, 2 layers where running
> in parallel, one feeding information to the other. Implementation is
> fairly easy... just have 2 arrays instead of 1, and update both arrays
> at each time step (just be careful which one, if any, you must update
> first)
>
> Jean
Won't this cause slowdowns because memory access becomes less local?
And if we fix that by interleaving the two arrays, then doesn't that just mean that the concept of layers has been lost in favor of extending state information? Because I think these are kind of synonymous things. Am I wrong?
Jean H.
> Jean H. wrote:
>> On a test, I developed once a "temporal game of life", where each cell
>> had 1) a state and 2) an age. Transition rules where based both on the
>> state and the age (a baby or elder can not give life, a baby can not die
>> of overcrowding but an elder can etc). Therefore, 2 layers where running
>> in parallel, one feeding information to the other. Implementation is
>> fairly easy... just have 2 arrays instead of 1, and update both arrays
>> at each time step (just be careful which one, if any, you must update
>> first)
>>
>> Jean
>
> Won't this cause slowdowns because memory access becomes less local?
I honestly didn't notice any slowdowns, but the dimensions of the array
were fairly small (like 250*250)
> And if we fix that by interleaving the two arrays, then doesn't that just mean that the concept of layers has been lost in favor of extending state information? Because I think these are kind of synonymous things. Am I wrong?
hum, I will leave the discussion on terminology open..
My point of view is that it is just a matter of representation. Take a
cube X*Y*Z. In memory, all X are contiguous, then all Y and finally all
Z. Rotate it, you get Z;X;Y. The Z's are now contiguous in memory...
but the concept of layers is still there!
Also, wouldn't an "extended state" be an array attached to each cell? so
if we have 1000 cells, we also have 1000 arrays of size N? In this case,
you don't really have layers but individual arrays. So even if you do
the interleave, you still have a layer, 1 variable in memory.
Jean
Tim Tyler
> Won't this cause slowdowns because memory access becomes less local?
>
> And if we fix that by interleaving the two arrays, then doesn't that
> just mean that the concept of layers has been lost in favor of extending
> state information? Because I think these are kind of synonymous things.
> Am I wrong?
Usually the idea of layers implies that there is a profitable breakdown
of the state information into separateish chunks that interact mostly
with their neighbours on the same layer. Interactions between layers
will exist - but are not so "full on", otherwise the idea of layers loses
its meaning.
If you have a layered 2D automaton, you can implement layers by using the
third dimension - assuming that layer interactions are local too. Then
there is not really any need for a slowdown.