; Langton-lambda and Entropy Computation
; B. J. MacLennan.  Aug. 2003

; (compute-HL (rs))
; Compute entropy and Langton's lambda from CA rule string.

(defun compute-HL (rs)
  (compute-freq-prob rs)
  (list 'entropy '= (entropy p)
	'lambda '= (- 1 (car p)))
  )

; (compute-freq-prob rs)
;
; Compute frequency table NumCfg and probability tabel p.

(defun compute-freq-prob (rs)
  (setq Nbd (1+ (* 2 Radius)))
  (setq newstate (digstring-to-intlist rs))
  (setq NumCfg (make-array States :initial-element 0))
  (setq RSL (length rs))
  (let ((fTotCfg (float (expt States Nbd))))
       (dotimes (s RSL)
		(let ((k (elt newstate s)))
		     (setf (aref NumCfg k) 
			   (+ (aref NumCfg k)
			      (configs s)))))
       (setq p (mapcar #'(lambda (nk) (/ nk fTotCfg))
		       (coerce NumCfg 'list)))
       ))

; (configs total)
;
; returns number of configurations that yield a given total

(defun configs (total)
  (if (and (= States 5) (= Nbd 3))
      (elt '(1 3 6 10 15 18 19 18 15 10 6 3 1) total)
      (print "Unsupported number of states & nbd size combination")))

; (plogp p)
; 
; computes p * lg(p), but returns 0.0 if p = 0.0.
; expects a floating point number

(defun plogp (p)
  (if (= 0.0 p)
      0.0
      (* p (log p 2))))

; (entropy probl)
;
; probl is a list of (at least two) floating point probabilities.

(defun entropy (probl)
  (- (reduce #'+ (mapcar #'plogp probl))))

; (digstring-to-intlist s)
;
; Convert digit string to list of integers.

(defun digstring-to-intlist (s)
  (mapcar #'digit-int (coerce s 'list)))

; (digit-int d)
;
; Convert digit character to an integer.

(defun digit-int (d)
  (search (list d) '(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)))

; Default Parameter Values

(setq States 5)
(setq Radius 1)