IgorCielniak/l2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rule110

Browse Source
This commit is contained in:
IgorCielniak
2026-02-03 09:03:44 +01:00
parent 5ea020100e
commit 2b78ca671c
3 changed files with 179 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
tests/rule110.expected Normal file
View File

@@ -0,0 +1,40 @@
#
##
###
## #
#####
## #
### ##
## # ###
####### #
## ###
### ## #
## # #####
##### ## #
## # ### ##
### #### # ###
## # ## ##### #
######## ## ###
## #### ## #
### ## # #####
## # ### #### #
##### ## ### # ##
## # ##### # ## ###
### ## ## ######## #
## # ###### ## ###
####### # ### ## #
## # #### # #####
### ## ## ### ## #
## # ### ### ## # ### ##
##### ## ### ###### ## # ###
## # ##### ### ######## #
### #### ### # ## ###
## # ## # ## ### ### ## #
######## ## ##### # ## # #####
## ###### ######## ## #
### ## # ## # ### ##
## # ### ## ### ## ## # ###
##### ## # ##### # ########## #
## # ##### ## ### ## ###
### ## ## #### ## # ### ## #
## # ###### ## # ##### ## # #####

138
tests/rule110.sl Normal file
View File

@@ -0,0 +1,138 @@
# Rule 110 Cellular Automaton
# Rule 110 is a Turing-complete cellular automaton
import stdlib/stdlib.sl
import stdlib/io.sl
import stdlib/mem.sl
# Configuration
macro WIDTH 0 80 ;
macro GENERATIONS 0 40 ;
# Apply Rule 110 to three cells (left center right -- new_state)
word rule110
swap 2 * # center*2
rot 4 * # left*4
+ + # pattern = left*4 + center*2 + right
dup 0 == if drop 0 else
dup 1 == if drop 1 else
dup 2 == if drop 1 else
dup 3 == if drop 1 else
dup 4 == if drop 0 else
dup 5 == if drop 1 else
dup 6 == if drop 1 else
dup 7 == if drop 0 else
drop 0
end end end end end end end end
end
# Print a single cell (state -- )
word print_cell
if 35 putc else 32 putc end
end
# Print the current generation (addr -- )
word print_gen
WIDTH
while dup 0 > do
over @ print_cell
swap 8 + swap
1 -
end
drop drop
10 putc
end
# Get cell with wraparound (ptr idx -- value)
word get_cell
dup 0 < if WIDTH + end
dup WIDTH >= if WIDTH - end
8 * + @
end
# Compute next generation (current next --)
word next_gen
over over # current next current next
0 # current next current next i
while dup WIDTH < do
# Stack (bottom->top): current next current next i
# Indices (0=top): i=0, next=1, current=2, next=3, current=4
# Get left neighbor: current[i-1]
2 pick # current
over # i
1 - get_cell
# Stack: current next current next i left
# Indices: left=0, i=1, next=2, current=3
# Get center: current[i]
3 pick # current
2 pick # i
get_cell
# Stack: current next current next i left center
# Get right: current[i+1]
4 pick # current
3 pick # i
1 + get_cell
# Stack: current next current next i left center right
rule110
# Stack: current next current next i result
# Store in next[i]
2 pick # next
2 pick # i
8 * + # addr
swap !
# Stack: current next current next i
1 +
end
drop
2drop
2drop
end
# Copy qword array (dest src count --)
word copy_arr
while dup 0 > do
over @ # get src value
3 pick swap ! # store at dest
swap 8 + swap # src += 8
rot 8 + -rot # dest += 8
1 -
end
drop 2drop
end
# Main entry point
word main
WIDTH 8 * alloc # current
WIDTH 8 * alloc # next
# Initialize current to zeros
over WIDTH for
dup 0 !
8 +
end
drop
# Set rightmost cell to 1
over WIDTH 1 - 8 * + 1 !
# Run simulation
GENERATIONS for
over print_gen
2dup next_gen
over over WIDTH copy_arr
end
# Free memory
swap WIDTH 8 * free
WIDTH 8 * free
0
end

1
tests/rule110.test Normal file
View File

@@ -0,0 +1 @@
python main.py tests/rule110.sl -o ./build/rule110 > /dev/null && ./build/rule110