Cellular automatas and me

2 weeks ago I started to read Philosophy and simulation by Manuel DeLanda (thanks eskerda).

About one month ago I watched jdelgado's talk at Campus Party talking about science in science fiction, and he talks a bit about cellular automata too:


So I started to experiment a bit with cellular automatas myself, and implemented a Conway game of life in smalltalk. At first I wanted to write a very flexible (1d,2d,...nd) cellular automata engine, but once I had the 2d Game of life implemented, I realized that doing 1d things is easier if you do it with strings, or just lists (lisp lists, for example).

Well, so I implemented a 1d cellular automata in common lisp (nice exercise) and tried some interesting rules for the majority problem jdelgado mentions in his talk.

At first I thought majority problem had a defined proper solution, but searching on the internetz, it seems it's not trivial at all, and I couldn't find anything that takes me further than rule 184, that splits the list in a group of 0's and 1's.

If you want the implementation of the smalltalk GoL, ask for it (it's not that easy to paste smalltalk code on the web, you know...), or just download any already existent implementations on squeaksource, like Bernat's one.

	;;; 1d cellular automata testbed
	;;; Raimon Grau
	;;; raimonster@gmail.com
	(defun run (&optional (length 11))
	(let ((population (list (gen-random-string length)))
	(rules (fill-rules (make-hash-table))))
	(loop while (not (equalp (first population) (second population)))
	do (setf population (cons (advance-generation population rules) population))
	(format t "~S~%" (first population)))
	(first population)))
	;;; rule 184: 101 110 00
	(defun fill-rules (hash-table)
	(setf (gethash 000 hash-table) #\0)
	(setf (gethash 001 hash-table) #\0)
	(setf (gethash 010 hash-table) #\0)
	(setf (gethash 011 hash-table) #\1)
	(setf (gethash 100 hash-table) #\1)
	(setf (gethash 101 hash-table) #\1)
	(setf (gethash 110 hash-table) #\0)
	(setf (gethash 111 hash-table) #\1)
	hash-table)
	(defun random-elt (sequence)
	(let ((seq-length (length sequence)))
	(when (> seq-length 0)
	(elt sequence (random seq-length)))))
	(defun gen-random-string (length)
	(let ((opts '(#\0 #\1)))
	(loop repeat length
	collect (random-elt opts))))
	;; (defun neighbours (data pos)
	;; (cond
	;; ((= pos 0) (cons (car (last data)) (subseq data 0 2)))
	;; ((= pos (1- (length data))) (append (subseq data (1- pos) (1+ pos)) (list (first data))))
	;; (t (subseq data (1- pos) (+ pos 2)))))
	(defun neighbours (data pos)
	(cond
	((= pos 0) (cons #\1 (subseq data 0 2)))
	((= pos (1- (length data))) (append (subseq data (1- pos) (1+ pos)) '(#\0)))
	(t (subseq data (1- pos) (+ pos 2)))))
	(defun advance-generation (population rules)
	(loop for elem in (first population)
	for pos from 0
	collect (apply-rule rules (neighbours (first population) pos))))
	(defun apply-rule (rules neighbours)
	(gethash (parse-integer (concatenate 'string neighbours)) rules))
	;;; (concatenate 'string '(#\a #\b))
	;;; adding to a hash (setf (gethash 'one-entry *my-hash*) "hola")

view raw cellular.lisp hosted with ❤ by GitHub