id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7,489 | synapse.lisp | kennytilton_its-alive/lisp/synapse.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(eval-when (:compile-toplevel :load-toplevel :execute)
(export '(mk-synapse f-delta f-sensitivity f-plusp f-zerop fdifferent with-synapse)))
(defmacro with-synapse (synapse-id (&rest closure-vars) &body body)
(let ((syn-id (gensym)))
`(let* ((,syn-id ,synapse-id)
(synapse (or (find ,syn-id (cd-useds *depender*) :key 'c-slot-name)
(let ((new-syn
(let (,@closure-vars)
(make-c-dependent
:model (c-model *depender*)
:slot-name ,syn-id
:code #+live nil #-live ',body
:synaptic t
:rule (c-lambda ,@body)))))
(record-caller new-syn)
new-syn))))
(prog1
(multiple-value-bind (v p)
(with-integrity ()
(ensure-value-is-current synapse :synapse *depender*))
(values v p))
(record-caller synapse)))))
;__________________________________________________________________________________
;
(defmethod delta-exceeds (bool-delta sensitivity (subtypename (eql 'boolean)))
(unless (eql bool-delta :unchanged)
(or (eq sensitivity t)
(eq sensitivity bool-delta))))
(defmethod delta-diff ((new number) (old number) subtypename)
(declare (ignore subtypename))
(- new old))
(defmethod delta-identity ((dispatcher number) subtypename)
(declare (ignore subtypename))
0)
(defmethod delta-abs ((n number) subtypename)
(declare (ignore subtypename))
(abs n))
(defmethod delta-exceeds ((d1 number) (d2 number) subtypename)
(declare (ignore subtypename))
(> d1 d2))
(defmethod delta-greater-or-equal ((d1 number) (d2 number) subtypename)
(declare (ignore subtypename))
(>= d1 d2))
;_________________________________________________________________________________
;
(defmethod delta-diff (new old (subtypename (eql 'boolean)))
(if new
(if old
:unchanged
:on)
(if old
:off
:unchanged)))
(defmethod delta-identity (dispatcher (subtypename (eql 'boolean)))
(declare (ignore dispatcher))
:unchanged)
| 2,402 | Common Lisp | .lisp | 61 | 30.032787 | 87 | 0.529539 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | e95a05d543cb68a159267c47eabf8c42d4cf10f01a541c914c68ce02f2d81c3a | 7,489 | [
-1
] |
7,490 | cells.lisp | kennytilton_its-alive/lisp/cells.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
#| Notes
I don't like the way with-cc defers twice, first the whole thing and then when the
body finally runs we are still within the original integrity and each setf gets queued
to UFB separately before md-slot-value-assume finally runs. I think all that is going on here
is that we want the programmer to use with-cc to show they know the setf will not be returning
a useful value. But since they have coded the with-cc we should be able to figure out a way to
let those SETFs thru as if they were outside integrity, and then we get a little less UFBing
but even better SETF behaves as it should.
It would be nice to do referential integrity and notice any time a model object gets stored in
a cellular slot (or in a list in such) and then mop those up on not-to-be.
|#
(in-package :cells)
(defparameter *c-prop-depth* 0)
(defparameter *causation* nil)
(defparameter *data-pulse-id* 0)
(define-symbol-macro .dpid *data-pulse-id*)
(defparameter *finbiz-id* 0) ;; debugging tool only
(define-symbol-macro .fbid *finbiz-id*)
(export! .dpid .fbid)
(defparameter *c-debug* nil)
(defparameter *c-prop-dep-trace* nil)
(defparameter *defer-changes* nil)
(defparameter *within-integrity* nil)
(defvar *istack*)
(defparameter *client-queue-handler* nil)
(defparameter *unfinished-business* nil)
(defparameter *not-to-be* nil)
(defparameter *md-awake* nil)
(defparameter *md-awake-where* :anon)
(defparameter *ntb-dbg* nil)
(defun md-awake-ct ()
(if *md-awake* (hash-table-count *md-awake*) 0))
(defun check-links (self where)
(assert (not (cells-flushed self)))
(print `(:model ,self ,where))
(loop for (nil . c) in (cells self)
do ;(print `(:cell ,c))
(loop for c2 in (c-callers c)
do (explore-caller c2))
(loop for c2 in (c-useds c)
do
(explore-used c2)))
(bgo 'check-links))
(defun explore-caller (c)
(unless (gethash (c-model c) *md-awake*)
(print `(:caller-outside? ,c))
(bgo 'explore-caller))
(loop for u in (c-callers c)
do (explore-caller u)))
(defun explore-used (c)
(unless (gethash (c-model c) *md-awake*)
(print `(:used-outside? ,c))
(bgo 'explore-used))
(loop for u in (c-useds c)
do (explore-used u)))
(defmacro with-none-awake ((&key dbg diag) &body body)
`(call-with-none-awake ,dbg (lambda () ,@body) ,diag))
(defun call-with-none-awake (dbg-info fn diag)
(let ((*md-awake* (make-hash-table :test 'eq #-sbcl :weak-keys #-sbcl t)))
(prog1
(funcall fn)
(when (md-awakep)
(if diag
(md-awake-map diag)
(progn
(print dbg-info)
(md-awake-dump)))
(brk "some awake ~a" dbg-info)))))
(defun md-awake-record (self &optional (where *md-awake-where*))
(when *md-awake*
;;(trcx md-awake-record self where)
(setf (gethash self *md-awake*) where)))
(defun md-awake-remove (self)
(when *md-awake*
(remhash self *md-awake*)))
(export! md-awake-dump md-awakep md-awake-remove md-awake-record with-none-awake
md-awake-dump-one *md-awake-where* md-awake-map)
(defun md-awakep ()
(plusp (md-awake-ct)))
(defun md-awake-dump ()
(let ((j (make-hash-table :test 'equal)))
(loop for x being the hash-keys of *md-awake*
using (hash-value where)
do (incf (gethash (list where (type-of x)) j 0)))
(maphash (lambda (k v)
(print (list "awake" k v))) j)
(loop for x being the hash-keys of *md-awake*
using (hash-value where)
do (md-awake-dump-one x where))))
(defun md-awake-map (fn)
(loop for x being the hash-keys of *md-awake*
using (hash-value where)
do (funcall fn x where)))
(defmethod md-awake-dump-one (x y)(declare (ignore x y)))
(defun cells-reset (&optional client-queue-handler &key debug)
(utils-kt-reset)
(setf
*c-debug* debug
*c-prop-dep-trace* nil
*c-prop-depth* 0
*not-to-be* nil
*ntb-dbg* nil
*data-pulse-id* 0
*finbiz-id* 0
*defer-changes* nil ;; should not be necessary, but cannot be wrong
*client-queue-handler* client-queue-handler
*within-integrity* nil
*unfinished-business* nil
*trcdepth* 0)
#-gogo (md-census-start)
(trc nil "------ cell reset ----------------------------"))
#+xx
(cells-reset)
(defparameter *c-stopper* 'c-stopper)
(defun c-stop (&optional why)
(funcall *c-stopper* why))
(defun c-stopper (why)
(setf *stop* t) ;; in webserver, make sure each thread binds this freshly
(print `(c-stop-entry ,why))
(format t "~&C-STOP> stopping because ~a" why) )
(define-symbol-macro .stop
(c-stop :user))
(defun c-stopped ()
*stop*)
(export! .stopped .cdbg)
(define-symbol-macro .cdbg
*c-debug*)
(define-symbol-macro .stopped
(c-stopped))
(defmacro c-assert (assertion &optional places fmt$ &rest fmt-args)
(declare (ignorable assertion places fmt$ fmt-args))
#+live `(progn)
#-live `(unless *stop*
(unless ,assertion
,(if fmt$
`(c-break ,fmt$ ,@fmt-args)
`(c-break "failed assertion: ~a" ',assertion)))))
(defmacro c-warn? (assertion &optional places fmt$ &rest fmt-args)
(declare (ignorable assertion places fmt$ fmt-args))
#+(or)`(progn)
`(unless *stop*
(unless ,assertion
,(if fmt$
`(c-warn ,fmt$ ,@fmt-args)
`(c-warn "failed assertion: ~a" ',assertion)))))
(defvar *call-stack* nil)
(defvar *depender* nil)
;; 2008-03-15: *depender* let's us differentiate between the call stack and
;; and dependency. The problem with overloading *call-stack* with both roles
;; is that we miss cyclic reentrance when we use without-c-dependency in a
;; rule to get "once" behavior or just when fm-traversing to find someone
(defmacro def-c-trace (model-type &optional slot cell-type)
`(defmethod trcp ((self ,(case cell-type
(:c? 'c-dependent)
(otherwise 'cell))))
(and (typep (c-model self) ',model-type)
,(if slot
`(eq (c-slot-name self) ',slot)
`t))))
(defmacro without-c-dependency (&body body)
`(let (*depender*)
,@body))
(defmacro with-c-dependency-if ((if) &body body)
`(if ,if
(progn ,body)
(let (*depender*)
,@body)))
(export! .cause with-c-dependency-if)
(define-symbol-macro .cause
(car *causation*))
(define-condition unbound-cell (unbound-slot)
((cell :initarg :cell :reader cell :initform nil)))
(defparameter *observe-why* nil) ;; debug aid
(defgeneric slot-value-observe (slotname self new old old-boundp cell)
#-(or cormanlisp)
(:method-combination progn))
#-cells-testing
(defmethod slot-value-observe #-(or cormanlisp) progn
(slot-name self new old old-boundp cell)
(declare (ignorable slot-name self new old old-boundp cell)))
#+hunh
(fmakunbound 'slot-value-observe)
; -------- cell conditions (not much used) ---------------------------------------------
(define-condition xcell () ;; new 2k0227
((cell :initarg :cell :reader cell :initform nil)
(app-func :initarg :app-func :reader app-func :initform 'bad-cell)
(error-text :initarg :error-text :reader error-text :initform "<???>")
(other-data :initarg :other-data :reader other-data :initform "<nootherdata>"))
(:report (lambda (c s)
(format s "~& trouble with cell ~a in function ~s,~s: ~s"
(cell c) (app-func c) (error-text c) (other-data c)))))
(define-condition c-enabling ()
((name :initarg :name :reader name)
(model :initarg :model :reader model)
(cell :initarg :cell :reader cell))
(:report (lambda (condition stream)
(format stream "~&unhandled <c-enabling>: ~s" condition)
(brk "~&i say, unhandled <c-enabling>: ~s" condition))))
(define-condition c-fatal (xcell)
((name :initform :anon :initarg :name :reader name)
(model :initform nil :initarg :model :reader model)
(cell :initform nil :initarg :cell :reader cell))
(:report (lambda (condition stream)
(format stream "~&fatal cell programming error: ~s" condition)
(format stream "~& : ~s" (name condition))
(format stream "~& : ~s" (model condition))
(format stream "~& : ~s" (cell condition)))))
(define-condition asker-midst-askers (c-fatal)
())
;; "see listener for cell rule cycle diagnotics"
(define-condition c-unadopted (c-fatal) ()
(:report
(lambda (condition stream)
(format stream "~&unadopted cell >: ~s" (cell condition))
(format stream "~& >: often you mis-edit (c? (c? ...)) nesting is error"))))
(defun c-break (&rest args)
(unless *stop*
(let ((*print-level* 5)
(*print-circle* t)
(args2 (mapcar 'princ-to-string args)))
(c-stop :c-break)
;(format t "~&c-break > stopping > ~{~a ~}" args2)
(apply 'error args2))))
(defun c-warn (&rest args)
(unless *stop*
(let ((*print-level* 5)
(*print-circle* t)
(args2 (mapcar 'princ-to-string args)))
;(format t "~&c-break > stopping > ~{~a ~}" args2)
(apply 'warn args2)))) | 9,217 | Common Lisp | .lisp | 234 | 34.376068 | 94 | 0.642697 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 0e8bc856aaee24f7868ed3117f1e80d300c9e580ad6e4de9644640f123887b86 | 7,490 | [
-1
] |
7,491 | family-values.lisp | kennytilton_its-alive/lisp/family-values.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(eval-when (:compile-toplevel :load-toplevel :execute)
(export '(family-values family-values-sorted
sort-index sort-direction sort-predicate sort-key
^sort-index ^sort-direction ^sort-predicate ^sort-key)))
(defmodel family-values (family)
(
(kv-collector :initarg :kv-collector
:initform #'identity
:reader kv-collector)
(kid-values :initform (c? (when (kv-collector self)
(funcall (kv-collector self) (^value))))
:accessor kid-values
:initarg :kid-values)
(kv-key :initform #'identity
:initarg :kv-key
:reader kv-key)
(kv-key-test :initform #'equal
:initarg :kv-key-test
:reader kv-key-test)
(kid-factory :initform #'identity
:initarg :kid-factory
:reader kid-factory)
(.kids :initform (c? (c-assert (listp (kid-values self)))
(let ((new-kids (mapcan (lambda (kid-value)
(list (or (find kid-value .cache
:key (kv-key self)
:test (kv-key-test self))
(trc nil "family-values forced to make new kid"
self .cache kid-value)
(funcall (kid-factory self) self kid-value))))
(^kid-values))))
(nconc (mapcan (lambda (old-kid)
(unless (find old-kid new-kids)
(when (fv-kid-keep self old-kid)
(list old-kid))))
.cache)
new-kids)))
:accessor kids
:initarg :kids)))
(defmethod fv-kid-keep (family old-kid)
(declare (ignorable family old-kid))
nil)
(defmodel family-values-sorted (family-values)
((sorted-kids :initarg :sorted-kids :accessor sorted-kids
:initform nil)
(sort-map :initform (c-in nil) :initarg :sort-map :accessor sort-map)
(.kids :initform (c? (c-assert (listp (kid-values self)))
(mapsort (^sort-map)
(the-kids
(mapcar (lambda (kid-value)
(trc "making kid" kid-value)
(or (find kid-value .cache :key (kv-key self) :test (kv-key-test self))
(trc nil "family-values forced to make new kid" self .cache kid-value)
(funcall (kid-factory self) self kid-value)))
(^kid-values)))))
:accessor kids
:initarg :kids)))
(defun mapsort (map data)
;;(trc "mapsort map" map)
(if map
(stable-sort data #'< :key (lambda (datum) (or (position datum map)
;(trc "mapsort datum not in map" datum)
(1+ (length data)))))
data))
(defobserver sorted-kids ()
(setf (sort-map self) new-value)) ;; cellular trick to avoid cyclicity | 3,374 | Common Lisp | .lisp | 71 | 30.478873 | 104 | 0.484876 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 80677794bcd949a0f1901f9ee1408285b52100d054817bc640cbd27c29965911 | 7,491 | [
-1
] |
7,492 | constructors.lisp | kennytilton_its-alive/lisp/constructors.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(eval-now!
(export '(.cache-bound-p
;; Cells Constructors
c?n
c?once
c?n-until
c?1
c_1
c?+n
;; Debug Macros and Functions
c?dbg
c_?dbg
c-input-dbg
)))
;___________________ constructors _______________________________
(defmacro c-lambda (&body body)
`(c-lambda-var (slot-c) ,@body))
(defmacro c-lambda-var ((c) &body body)
`(lambda (,c &aux (self (c-model ,c))
(.cache (c-value ,c))
(.cache-bound-p (cache-bound-p ,c)))
(declare (ignorable .cache .cache-bound-p self))
,@body))
(defmacro with-c-cache ((fn) &body body)
(let ((new (gensym)))
`(or (bwhen (,new (progn ,@body))
(funcall ,fn ,new .cache))
.cache)))
;-----------------------------------------
(defmacro c? (&body body)
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:rule (c-lambda ,@body)))
(defmacro c?+n (&body body)
`(make-c-dependent
:inputp t
:code #+live nil #-live ',body
:value-state :unevaluated
:rule (c-lambda ,@body)))
(defmacro c?n (&body body)
`(make-c-dependent
:code '(without-c-dependency ,@body)
:inputp t
:value-state :unevaluated
:rule (c-lambda (without-c-dependency ,@body))))
(defmacro c_?n (&body body)
`(make-c-dependent
:code '(without-c-dependency ,@body)
:inputp t
:lazy :until-asked
:value-state :unevaluated
:rule (c-lambda (without-c-dependency ,@body))))
(export! c?n-dbg c_?n)
(defmacro c?n-dbg (&body body)
`(make-c-dependent
:code '(without-c-dependency ,@body)
:inputp t
:debug t
:value-state :unevaluated
:rule (c-lambda (without-c-dependency ,@body))))
(defmacro c?n-until (args &body body)
`(make-c-dependent
:optimize :when-value-t
:code #+live nil #-live ',body
:inputp t
:value-state :unevaluated
:rule (c-lambda ,@body)
,@args))
(defmacro c?once (&body body)
`(make-c-dependent
:code '(without-c-dependency ,@body)
:inputp nil
:value-state :unevaluated
:rule (c-lambda (without-c-dependency ,@body))))
(defmacro c_1 (&body body)
`(make-c-dependent
:code '(without-c-dependency ,@body)
:inputp nil
:lazy t
:value-state :unevaluated
:rule (c-lambda (without-c-dependency ,@body))))
(defmacro c?1 (&body body)
`(c?once ,@body))
(defmacro c?dbg (&body body)
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:debug t
:rule (c-lambda ,@body)))
(defmacro c?_ (&body body)
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:lazy t
:rule (c-lambda ,@body)))
(defmacro c_? (&body body)
"Lazy until asked, then eagerly propagating"
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:lazy :until-asked
:rule (c-lambda ,@body)))
(defmacro c_?dbg (&body body)
"Lazy until asked, then eagerly propagating"
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:lazy :until-asked
:rule (c-lambda ,@body)
:debug t))
(defmacro c?? ((&key (tagp nil) (in nil) (out t))&body body)
(let ((result (copy-symbol 'result))
(thetag (gensym)))
`(make-c-dependent
:code #+live nil #-live ',body
:value-state :unevaluated
:rule (c-lambda
(let ((,thetag (gensym "tag"))
(*trcdepth* (1+ *trcdepth*))
)
(declare (ignorable self ,thetag))
,(when in
`(trc "c??> entry" (c-slot-name c) (c-model c) (when ,tagp ,thetag)))
(count-it :c?? (c-slot-name c) (md-name (c-model c)))
(let ((,result (progn ,@body)))
,(when out `(trc "c?? result:" ,result (c-slot-name c) (when ,tagp ,thetag)))
,result))))))
(defmacro c-formula ((&rest keys &key lazy &allow-other-keys) &body forms)
(assert (member lazy '(nil t :once-asked :until-asked :always)))
`(make-c-dependent
:code ',forms
:value-state :unevaluated
:rule (c-lambda ,@forms)
,@keys))
(defmacro c-input ((&rest keys) &optional (value nil valued-p))
`(make-cell
:inputp t
:value-state ,(if valued-p :valid :unbound)
:value ,value
,@keys))
(defmacro c-in (value)
`(make-cell
:inputp t
:value-state :valid
:value ,value))
(export! c-in-lazy c_in)
(defmacro c-in-lazy (&body body)
`(c-input (:lazy :once-asked) (progn ,@body)))
(defmacro c_in (&body body)
`(c-input (:lazy :once-asked) (progn ,@body)))
(defmacro c-input-dbg (&optional (value nil valued-p))
`(make-cell
:inputp t
:debug t
:value-state ,(if valued-p :valid :unbound)
:value ,value))
(defmacro c... ((value) &body body)
`(make-c-drifter
:code #+live nil #-live ',body
:value-state :valid
:value ,value
:rule (c-lambda ,@body)))
(defmacro c-abs (value &body body)
`(make-c-drifter-absolute
:code #+live nil #-live ',body
:value-state :valid
:value ,value
:rule (c-lambda ,@body)))
(defmacro c-envalue (&body body)
`(make-c-envaluer
:envalue-rule (c-lambda ,@body)))
| 5,423 | Common Lisp | .lisp | 177 | 24.977401 | 95 | 0.581892 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 4fa52743baab51e677db09605954591333e6cde0c153fa96a187e39aa8271f39 | 7,492 | [
-1
] |
7,493 | cell-types.lisp | kennytilton_its-alive/lisp/cell-types.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(defstruct (cell (:conc-name c-))
model
slot-name
value
inputp ;; t for old c-variable class
synaptic
(caller-store (make-fifo-queue) :type cons) ;; (C3) probably better to notify callers FIFO
(state :nascent :type symbol) ;; :nascent, :awake, :optimized-away
(value-state :unbound :type symbol) ;; {:unbound | :unevaluated | :uncurrent | :valid}
; uncurrent (aka dirty) new for 06-10-15. we need this so
; c-quiesce can force a caller to update when asked
; in case the owner of the quiesced cell goes out of existence
; in a way the caller will not see via any kids dependency. Saw
; this one coming a long time ago: depending on cell X implies
; a dependency on the existence of instance owning X
(pulse 0 :type fixnum)
(pulse-last-changed 0 :type fixnum) ;; lazys can miss changes by missing change of X followed by unchange of X in subsequent DP
(pulse-observed 0 :type fixnum)
lazy
(optimize t)
debug
md-info)
;_____________________ print __________________________________
#+sigh
(defmethod print-object :before ((c cell) stream)
(declare (ignorable stream))
#+shhh (unless (or *stop* *print-readably*)
(format stream "[~a~a:" (if (c-inputp c) "i" "?")
(cond
((null (c-model c)) #\0)
((eq :eternal-rest (md-state (c-model c))) #\_)
((not (c-currentp c)) #\#)
(t #\space)))))
(defmethod print-object ((c cell) stream)
(declare (ignorable stream))
(if *stop*
(format stream "<~d:~a ~a/~a = ~a>"
(c-pulse c)
(subseq (string (c-state c)) 0 1)
(symbol-name (or (c-slot-name c) :anoncell))
(md-name (c-model c))
(type-of (c-value c)))
(let ((*print-circle* t))
#+failsafe (format stream "~a/~a" (c-model c)(c-slot-name c))
(if *print-readably*
(call-next-method)
(progn
(c-print-value c stream)
(format stream "<~a ~d:~a ~a/~a = ~a>"
(type-of c)
(c-pulse c)
(subseq (string (c-state c)) 0 1)
(symbol-name (or (c-slot-name c) :anoncell))
(print-cell-model (c-model c))
(if (consp (c-value c))
"LST" (c-value c))))))))
(export! print-cell-model)
(defgeneric print-cell-model (md)
(:method (other) (print-object other nil)))
(defmethod trcp :around ((c cell))
(and ;*c-debug*
(or (c-debug c)
(call-next-method))))
(defun c-callers (c)
"Make it easier to change implementation"
(fifo-data (c-caller-store c)))
(defun caller-ensure (used new-caller)
(unless (find new-caller (c-callers used))
(trc nil "caller-ensure fifo-adding new-caller" new-caller :used used)
(fifo-add (c-caller-store used) new-caller)))
(defun caller-drop (used caller)
(fifo-delete (c-caller-store used) caller))
; --- ephemerality --------------------------------------------------
;
; Not a type, but an option to the :cell parameter of defmodel
;
(defun ephemeral-p (c)
(eql :ephemeral (md-slot-cell-type (type-of (c-model c)) (c-slot-name c))))
(defun ephemeral-reset (c)
(when (ephemeral-p c) ;; so caller does not need to worry about this
;
; as of Cells3 we defer resetting ephemerals because everything
; else gets deferred and we cannot /really/ reset it until
; within finish_business we are sure all callers have been recalculated
; and all outputs completed.
;
; ;; good q: what does (setf <ephem> 'x) return? historically nil, but...?
;
;;(trcx bingo-ephem c)
(with-integrity (:ephemeral-reset c)
(trc nil "!!!!!!!!!!!!!! ephemeral-reset resetting:" c)
(md-slot-value-store (c-model c) (c-slot-name c) nil)
(setf (c-value c) nil))))
; -----------------------------------------------------
(defun c-validate (self c)
(when (not (and (c-slot-name c) (c-model c)))
(format t "~&unadopted cell: ~s md:~s" c self)
(c-break "unadopted cell ~a ~a" self c)
(error 'c-unadopted :cell c)))
(defstruct (c-ruled
(:include cell)
(:conc-name cr-))
(code nil :type list) ;; /// feature this out on production build
rule)
(defun c-optimized-away-p (c)
(eq :optimized-away (c-state c)))
;----------------------------
(defmethod trcp-slot (self slot-name)
(declare (ignore self slot-name)))
(defstruct (c-dependent
(:include c-ruled)
(:conc-name cd-))
;; chop (synapses nil :type list)
(useds nil :type list)
(usage (blank-usage-mask)))
(defun blank-usage-mask ()
(make-array 64 :element-type 'bit
:initial-element 0))
#+xxxx
(cd-usage nil)
#+xxx
(test-xxx)
(defun test-xxx ()
(let ((u (blank-usage-mask)))
(setf (sbit u 25) 1)))
(defstruct (c-drifter
(:include c-dependent)))
(defstruct (c-drifter-absolute
(:include c-drifter)))
;_____________________ accessors __________________________________
(defmethod c-useds (other) (declare (ignore other)))
(defmethod c-useds ((c c-dependent)) (cd-useds c))
(defun c-validp (c)
(eql (c-value-state c) :valid))
(defun c-unboundp (c)
(eql :unbound (c-value-state c)))
;__________________
(defmethod c-print-value ((c c-ruled) stream)
(format stream "~a" (cond ((c-validp c) (cons (c-value c) "<vld>"))
((c-unboundp c) "<unb>")
((not (c-currentp c)) "dirty")
(t "<err>"))))
(defmethod c-print-value (c stream)
(declare (ignore c stream)))
| 5,915 | Common Lisp | .lisp | 149 | 32.369128 | 129 | 0.558937 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | a2b6cef8f44200002c25f3e9dcfb2114282aa27f6ee8a57ce984d54345af9ee4 | 7,493 | [
-1
] |
7,494 | test-synapse.lisp | kennytilton_its-alive/lisp/test-synapse.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
;;;
;;; Copyright (c) 1995,2003 by Kenneth William Tilton.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is furnished
;;; to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
;;; IN THE SOFTWARE.
(in-package :cells)
(defmodel m-syn ()
((m-syn-a :initform nil :initarg :m-syn-a :accessor m-syn-a)
(m-syn-b :initform nil :initarg :m-syn-b :accessor m-syn-b)
(m-syn-factor :initform nil :initarg :m-syn-factor :accessor m-syn-factor)
(m-sens :initform nil :initarg :m-sens :accessor m-sens)
(m-plus :initform nil :initarg :m-plus :accessor m-plus)
))
(def-c-output m-syn-b ()
(print `(output m-syn-b ,self ,new-value ,old-value)))
(def-cell-test m-syn
(progn (cell-reset)
(let* ((delta-ct 0)
(sens-ct 0)
(plus-ct 0)
(m (make-be 'm-syn
:m-syn-a (c-in 0)
:m-syn-b (c? (incf delta-ct)
(trc nil "syn-b rule firing!!!!!!!!!!!!!!" delta-ct)
(eko (nil "syn-b rule returning")
(f-delta :syna-1 (:sensitivity 2)
(^m-syn-a))))
:m-syn-factor (c-in 1)
:m-sens (c? (incf sens-ct)
(trc nil "m-sens rule firing ~d !!!!!!!!!!!!!!" sens-ct)
(* (^m-syn-factor)
(f-sensitivity :sensa (3) (^m-syn-a))))
:m-plus (c? (incf plus-ct)
(trc nil "m-plus rule firing!!!!!!!!!!!!!!" plus-ct)
(f-plusp :syna-2 (- 2 (^m-syn-a)))))))
(ct-assert (= 1 delta-ct))
(ct-assert (= 1 sens-ct))
(ct-assert (= 1 plus-ct))
(ct-assert (= 0 (m-sens m)))
(trc "make-be complete. about to incf m-syn-a")
(incf (m-syn-a m))
(ct-assert (= 1 delta-ct))
(ct-assert (= 1 sens-ct))
(ct-assert (= 1 plus-ct))
(ct-assert (= 0 (m-sens m)))
(trc "about to incf m-syn-a 2")
(incf (m-syn-a m) 2)
(trc nil "syn-b now" (m-syn-b m))
(ct-assert (= 2 delta-ct))
(ct-assert (= 2 sens-ct))
(ct-assert (= 2 plus-ct))
(ct-assert (= 3 (m-sens m)))
(trc "about to incf m-syn-a")
(incf (m-syn-a m))
(ct-assert (= 2 delta-ct))
(ct-assert (= 2 sens-ct))
(trc "about to incf m-syn-factor")
(incf (m-syn-factor m))
(ct-assert (= 3 sens-ct))
(ct-assert (= (m-sens m) (* (m-syn-factor m) (m-syn-a m))))
(trc "about to incf m-syn-a xxx")
(incf (m-syn-a m))
(ct-assert (= 2 delta-ct))
(ct-assert (= 3 sens-ct))
(trc "about to incf m-syn-a yyyy")
(incf (m-syn-a m))
(ct-assert (= 3 delta-ct))
(ct-assert (= 4 sens-ct))
(ct-assert (= 2 plus-ct))
(describe m)
(print '(start)))))
(Def-c-output m-syn-a ()
(trc "!!! M-SYN-A now =" new-value))
#+(or)
(m-syn)
| 4,037 | Common Lisp | .lisp | 91 | 35.197802 | 84 | 0.5452 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 52ae75cfb143e5ff279e5e92bc138fc505371bfb1a711149b8ba6e639dc87e42 | 7,494 | [
-1
] |
7,495 | fm-utilities.lisp | kennytilton_its-alive/lisp/fm-utilities.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(eval-when (:compile-toplevel :load-toplevel :execute)
(export
'(;; Family member creation
make-part
mk-part
mk-part-spec
upper
u^
kontainer
container-typed
;; Family member finding
fm-descendant-typed
fm-ascendant-typed
fm-kid-named
fm-descendant-named
fm-ascendant-named
fm-ascendant-some
fm-ascendant-if
fm-descendant-if
fm-descendant-common
fm-collect-if
fm-collect-some
fm-value-dictionary
fm-max
fm-traverse
fm-traverse-bf
fm-ordered-p
sub-nodes
fm-ps-parent
with-like-fm-parts
do-like-fm-parts
true-that
fm-do-up
fm-gather
fm-find-all
fm-find-next
fm-find-next-within
fm-find-prior
fm-find-prior-within
fm-find-last-if
fm-prior-sib
fm-next-sib-if
fm-next-sib
^fm-next-sib
fm-find-if
;; Family ordering
fm-kid-add
fm-kid-insert-last
fm-kid-insert-first
fm-kid-insert
fm-kid-remove
fm-quiesce-all
fm-kid-replace
;; Family high-order ops
fm-min-kid
fm-max-kid
fm-other
fmv
fm-otherx
fm-other-v
fm-otherv?
fm-other?
fm-other!
fm^ fm^v
fm?
fm!
fm!v
fm-other?!
fm-collect
fm-map
fm-mapc
fm-pos
fm-count-named
fm-count
fm-top
fm-first-above
fm-nearest-if
fm-includes
fm-ancestor-p
fm-kid-containing
fm-ascendant-p
fm-find-one
fm-find-kid
fm-kid-typed
;; Other family stuff
make-name
name-root
name-subscript
kid-no
n^
;; Debug flags
*fmdbg*
)))
(defparameter *fmdbg* nil)
(defun make-part (partname part-class &rest initargs)
;;(trc "make-part > name class" partname partclass)
(when part-class ;;a little programmer friendliness
(apply #'make-instance part-class (append initargs (list :md-name partname)))))
(defmacro mk-part (md-name (md-class) &rest initargs)
`(make-part ',md-name ',md-class ,@initargs
:fm-parent (progn (assert self () "mk-part null self for parent") self)))
(defmethod make-part-spec ((part-class symbol))
(make-part part-class part-class))
(defmethod make-part-spec ((part model))
part)
(defmacro upper (self &optional (type t))
`(container-typed ,self ',type))
(defmacro u^ (type)
`(upper self ,type))
(defmacro u^v (type)
`(value (upper self ,type)))
(defmacro n^ (type)
`(nearest self ,type))
(defmacro n^v (type)
`(value (nearest self ,type)))
(export! u^v n^v)
(defmethod kontainer (self) (fm-parent self))
(defmethod container-typed ((self model-object) type)
(let ((parent (kontainer self))) ;; fm- or ps-parent
(cond
((null parent) nil)
((typep parent type) parent)
(t (container-typed parent type)))))
(defun fm-descendant-typed (self type)
(when self
(or (find-if (lambda (k) (typep k type)) (kids self))
(some (lambda (k)
(fm-descendant-typed k type)) (kids self)))))
(defun fm-kid-named (self name)
(find name (^kids) :key 'md-name))
(defun fm-descendant-named (parent name &key (must-find t))
(fm-find-one parent name :must-find must-find :global-search nil))
(defun fm-ascendant-named (parent name)
(when parent
(or (when (eql (md-name parent) name)
parent)
(fm-ascendant-named (fm-parent parent) name))))
(defun fm-ascendant-typed (parent name)
(when parent
(or (when (typep parent name)
parent)
(fm-ascendant-typed (fm-parent parent) name))))
(defun fm-ascendant-some (parent some-function)
(when (and parent some-function)
(or (funcall some-function parent)
(fm-ascendant-some (fm-parent parent) some-function))))
(defun fm-ascendant-if (self test)
(when (and self test)
(or (when (funcall test self)
self)
(fm-ascendant-if .parent test))))
(defun fm-descendant-if (self test)
(when (and self test)
(or (when (funcall test self)
self)
(loop for k in (^kids)
thereis (fm-descendant-if k test)))))
(defun fm-ascendant-common (d1 d2)
(fm-ascendant-some d1 (lambda (node)
(when (fm-includes node d2)
node))))
(defun fm-collect-if (tree test &optional skip-top dependently)
(let (collection)
(fm-traverse tree (lambda (node)
(unless (and skip-top (eq node tree))
(when (funcall test node)
(push node collection))))
:with-dependency dependently)
(nreverse collection)))
(defun fm-collect-some (tree test &optional skip-top dependently)
(let (collection)
(fm-traverse tree (lambda (node)
(unless (and skip-top (eq node tree))
(bwhen (s (funcall test node))
(push s collection))))
:with-dependency dependently)
(nreverse collection)))
(defun fm-value-dictionary (tree value-fn &optional include-top)
(let (collection)
(fm-traverse tree
(lambda (node)
(when (or include-top (not (eq node tree)))
(bwhen (v (funcall value-fn node))
(push (cons (md-name node) v) collection)))))
(nreverse collection)))
(defun fm-max (tree key)
(let (max)
(fm-traverse tree (lambda (node)
(if max
(setf max (max max (funcall key node)))
(setf max (funcall key node)))))
max))
(defun fm-traverse (family applied-fn &key skip-node skip-tree global-search opaque with-dependency)
;;(when *fmdbg* (trc "fm-traverse" family skipTree skipNode global-search))
(when family
(labels ((tv-family (fm)
(etypecase fm
(cons (loop for md in fm do (tv-family md)))
(model-object
(unless (eql fm skip-tree)
(let ((outcome (and (not (eql skip-node fm)) ;; skipnode new 990310 kt
(funcall applied-fn fm))))
(unless (and outcome opaque)
(dolist (kid (kids fm))
(tv-family kid))
;(tv-family (mdValue fm))
)))))))
(flet ((tv ()
(tv-family family)
(when global-search
(fm-traverse (fm-parent family) applied-fn
:global-search t
:skip-tree family
:skip-node skip-node
:with-dependency t)))) ;; t actually just defaults to outermost call
(if with-dependency
(tv)
(without-c-dependency (tv))))))
(values))
(defun fm-traverse-bf (family applied-fn &optional (cq (make-fifo-queue)))
(when family
(flet ((process-node (fm)
(funcall applied-fn fm)
(when (kids fm)
(fifo-add cq (kids fm)))))
(process-node family)
(loop for x = (fifo-pop cq)
while x
do (mapcar #'process-node x)))))
#+test-bf
(progn
(defmd bftree (family)
(depth 0 :cell nil)
(id (c? (klin self)))
:kids (c? (when (< (depth self) 4)
(loop repeat (1+ (depth self))
collecting (make-kid 'bftree :depth (1+ (depth self)))))))
(defun klin (self)
(when self
(if .parent
(cons (kid-no self) (klin .parent))
(list 0))))
(defun test-bf ()
(let ((self (make-instance 'bftree)))
(fm-traverse-bf self
(lambda (node)
(print (id node)))))))
(defun fm-ordered-p (n1 n2 &aux (top (fm-ascendant-common n1 n2)))
(assert top)
(fm-traverse top (lambda (n)
(cond
((eq n n1)(return-from fm-ordered-p t))
((eq n n2)(return-from fm-ordered-p nil))))))
(defun kids-ordered (k1 k2)
(assert (eq (fm-parent k1)(fm-parent k2)))
(if (find k2 (member k1 (kids (fm-parent k1))))
(list k1 k2)
(list k2 k1)))
(export! kids-ordered)
(defmethod sub-nodes (other)
(declare (ignore other)))
(defmethod sub-nodes ((self family))
(kids self))
(defmethod fm-ps-parent ((self model-object))
(fm-parent self))
(defmacro with-like-fm-parts ((parts-var (self like-class)) &body body)
`(let (,parts-var)
(fm-traverse ,self (lambda (node)
;;(trc "with like sees node" node (type-of node) ',likeclass)
(when (typep node ',like-class)
(push node ,parts-var)))
:skip-node ,self
:opaque t)
(setf ,parts-var (nreverse ,parts-var))
(progn ,@body)))
(defmacro do-like-fm-parts ((part-var (self like-class) &optional return-var) &body body)
`(progn
(fm-traverse ,self (lambda (,part-var)
(when (typep ,part-var ',like-class)
,@body))
:skip-node ,self
:opaque t)
,return-var)
)
;;
;; family member finding
;;
#|
(defun fm-member-named (kidname kids)
(member kidname kids :key #'md-name))
|#
(defun true-that (that) (declare (ignore that)) t)
;;
;; eventually fm-find-all needs a better name (as does fm-collect) and they
;; should be modified to go through 'gather', which should be the real fm-find-all
;;
(export! fm-heritage)
(defun fm-heritage (self)
(loop for p = self then (fm-parent p)
while p
collect (list p (md-name p) (type-of p) (cz::md-state p))))
(defun fm-do-up (self &optional (fn 'identity))
(when self
(funcall fn self)
(if .parent (fm-do-up .parent fn) self))
(values))
(defun fm-gather (family &key (test #'true-that))
(packed-flat!
(cons (when (funcall test family) family)
(mapcar (lambda (fm)
(fm-gather fm :test test))
(kids family)))))
(defun fm-find-all (family md-name &key (must-find t) (global-search t))
(let ((matches (catch 'fm-find-all
(with-dynamic-fn
(traveller (family)
(with-dynamic-fn
(filter (kid) (eql md-name (md-name kid)))
(let ((matches (remove-if-not filter (kids family))))
(when matches
(throw 'fm-find-all matches)))))
(fm-traverse family traveller :global-search global-search)))))
(when (and must-find (null matches))
(c-stop :fm-find-all-must-find-failed)
(describe family)
(loop for h in (fm-heritage family)
do (trcx heritage-ayway h))
(fm-traverse family (lambda (node)
(trc "known node" (md-name node))) :global-search global-search)
(brk "fm-find-all > *stop*ping...did not find ~a ~a ~a" family md-name global-search)
;; (error 'fm-not-found (list md-name family global-search))
)
matches))
(defun fm-find-next (fm test-fn)
(fm-find-next-within fm test-fn))
(defun fm-find-next-within (fm test-fn &optional upperbound &aux (fm-parent (unless (eql upperbound fm)
(fm-parent fm))))
(let ((sibs (and fm-parent (rest (member fm (kids fm-parent))))))
(or (dolist (s sibs)
(let ((winner (fm-find-if s test-fn)))
(when winner (return winner))))
(if fm-parent
(fm-find-next-within fm-parent test-fn upperbound)
(fm-find-if fm test-fn)))))
(defun fm-find-prior (fm test-fn)
(fm-find-prior-within fm test-fn))
(defun fm-find-prior-within (fm test-fn &optional upperbound &aux (fm-parent (unless (eql upperbound fm)
(fm-parent fm))))
(let ((sibs (and fm-parent (kids fm-parent))))
(or (loop with next-ok
for s on sibs
for last-ok = nil then (or next-ok last-ok)
when (eql fm (first s)) do (loop-finish)
finally (return last-ok)
do (setf next-ok (fm-find-last-if (car s) test-fn)))
(if fm-parent
(fm-find-prior-within fm-parent test-fn upperbound)
(fm-find-last-if fm test-fn)))))
(defun fm-find-last-if (family test-fn)
(let ((last))
(or (and (kids family)
(dolist (k (kids family) last)
(setf last (or (fm-find-last-if k test-fn) last))))
(when (funcall test-fn family)
family))))
(defun fm-psib (self test-fn)
(some test-fn (cdr (member self (kids (fm-parent self))))))
(defun fm-prior-sib (self &optional (test-fn #'true-that))
"Find nearest preceding sibling passing TEST-FN"
(chk self 'psib)
(let ((kids (kids (fm-parent self))))
(find-if test-fn kids :end (position self kids) :from-end t)))
(defun fm-next-sib-if (self test-fn)
(some test-fn (cdr (member self (kids (fm-parent self))))))
(defun fm-next-sib (self)
(car (cdr (member self (kids (fm-parent self))))))
(defmacro ^fm-next-sib (&optional (self 'self))
(let ((s (gensym)))
`(let ((,s ,self))
(car (cdr (member ,s (kids (fm-parent ,s))))))))
(defun find-prior (self sibs &key (test #'true-that))
(c-assert (member self sibs) () "find-prior of ~a does not find it in sibs arg ~a" self sibs)
(unless (eql self (car sibs))
(labels
((fpsib (rsibs &aux (psib (car rsibs)))
(c-assert rsibs () "find-prior > fpsib > self ~s not found to prior off" self)
(if (eql self (cadr rsibs))
(when (funcall test psib) psib)
(or (fpsib (cdr rsibs))
(when (funcall test psib) psib)))))
(fpsib sibs))))
(defun fm-find-if (family test-fn &key skip-top-p) ;; 99-03 kt why is thsi depth-first?
(c-assert test-fn)
(when family
(or (dolist (b (sub-nodes family))
(let ((match (fm-find-if b test-fn)))
(when match (return match))))
(when (and (not skip-top-p)
(funcall test-fn family))
family))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;
;;;; family ordering
;;;;
(defun fm-kid-add (fm-parent kid &optional before)
(c-assert (or (null (fm-parent kid)) (eql fm-parent (fm-parent kid))))
(c-assert (typep fm-parent 'family))
(setf (fm-parent kid) fm-parent)
(fm-kid-insert kid before))
(defun fm-kid-insert-last (goal &aux (fm-parent (fm-parent goal)))
(setf (kids fm-parent) (nconc (kids fm-parent) (list goal))))
(defun fm-kid-insert-first (goal &aux (fm-parent (fm-parent goal)))
(setf (kids fm-parent) (cons goal (kids fm-parent))))
(defun fm-kid-insert (kid &optional before &aux (da-kids (kids (fm-parent kid))))
(c-assert (or (null before) (eql (fm-parent kid) (fm-parent before))))
(setf (kids (fm-parent kid))
(if before
(if (eql before (car da-kids))
(cons kid da-kids)
(let ((cell (member before da-kids)))
(rplaca cell kid)
(rplacd cell (cons before (cdr cell)))
(cons (car da-kids) (rest da-kids))))
(if da-kids
(progn
(rplacd (last da-kids) (cons kid nil))
(cons (car da-kids) (rest da-kids)))
(cons kid da-kids)))))
(defun fm-kid-remove (kid &key (quiesce t) &aux (parent (fm-parent kid)))
(when quiesce
(fm-quiesce-all kid))
(when parent
(setf (kids parent) (remove kid (kids parent)))
;; (setf (fm-parent kid) nil) gratuitous housekeeping caused ensuing focus output
;; image-invalidate to fail since no access to containing window via fm-parent chain
))
(defun fm-quiesce-all (md)
(md-quiesce md)
(dolist (kid (kids md))
(fm-quiesce-all kid)))
(defun fm-kid-replace (old-kid new-kid &aux (fm-parent (fm-parent old-kid)))
(c-assert (member old-kid (kids fm-parent)) ()
"~&oldkid ~s not amongst kids of its fm-parent ~s"
old-kid fm-parent)
(when fm-parent ;; silly test given above assert--which is right?
(c-assert (typep fm-parent 'family))
(setf (fm-parent new-kid) fm-parent)
(setf (kids fm-parent) (substitute new-kid old-kid (kids fm-parent)))
new-kid))
;----------------------------------------------------------
;;
;; h i g h - o r d e r f a m i l y o p s
;;
;; currently not in use...someday?
;;
(defun fm-min-kid (self slot-name)
(or (loop for k in (^kids)
minimizing (funcall slot-name k))
0))
(defun fm-max-kid (self slot-name)
(or (loop for k in (^kids)
maximizing (funcall slot-name k))
0))
(defmacro fm-other (md-name &key (starting 'self) skip-tree (test '#'true-that))
`(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find t
:skip-tree ,skip-tree
:global-search t
:test ,test))
(defmacro fmv (name)
`(value (fm-other ,name)))
(defmacro fm-otherx (md-name &key (starting 'self) skip-tree)
(if (eql starting 'self)
`(or (fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find t
:skip-tree ,skip-tree
:global-search t))
`(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find t
:skip-tree ,skip-tree
:global-search t)))
(defun fm-other-v (md-name starting &optional (global-search t))
(fm-find-one starting md-name
:must-find nil
:global-search global-search))
(defmacro fm-otherv? (md-name &optional (starting 'self) (global-search t))
`(fm-other-v ,md-name ,starting ,global-search))
(defmacro fm-other? (md-name &optional (starting 'self) (global-search t))
`(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find nil
:global-search ,global-search))
(defun fm-other! (starting md-name &optional (global-search t))
(fm-find-one starting md-name
:must-find t
:global-search global-search))
(defmacro fm^ (md-name &key (skip-tree 'self) (must-find t))
`(without-c-dependency
(fm-find-one (fm-parent self) ,md-name
:skip-tree ,skip-tree
:must-find ,must-find
:global-search t)))
(defmacro fm^v (id)
`(value (fm^ ,id)))
(defmacro fm^^ (scope-md-name md-name)
(let ((scope (gensym)))
`(let ((,scope (fm-ascendant-named self ,scope-md-name)))
(assert ,scope () "fm^^ unable to locate scope named ~a starting at ~a" ,scope-md-name self)
(without-c-dependency
(fm-find-one ,scope ,md-name
:skip-tree self
:must-find t
:global-search nil)))))
(defmacro fm^^v (scope-md-name md-name)
`(value (fm^^ ,scope-md-name ,md-name)))
(export! fm^^ fm^^v)
(defmacro fm? (md-name &optional (starting 'self) (global-search t))
`(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find nil
:global-search ,global-search))
(defmacro fm! (md-name &optional (starting 'self))
`(without-c-dependency
(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find t
:global-search nil)))
(defmacro fm!v (id)
`(value (fm! ,id)))
(defmacro fm-other?! (md-name &optional (starting 'self))
`(fm-find-one ,starting ,(if (consp md-name)
`(list ',(car md-name) ,(cadr md-name))
`',md-name)
:must-find nil
:global-search nil))
(defmacro fm-collect (md-name &key (must-find t))
`(fm-find-all self ',md-name :must-find ,must-find)) ;deliberate capture
(defmacro fm-map (fn md-name)
`(mapcar ,fn (fm-find-all self ',md-name))) ;deliberate capture
(defmacro fm-mapc (fn md-name)
`(mapc ,fn (fm-find-all self ',md-name))) ;deliberate capture
(defun fm-pos (goal &aux (fm-parent (fm-parent goal)))
(when fm-parent
(or (position goal (kids fm-parent))
(length (kids fm-parent))))) ;; ?!!
(defmacro fm-count-named (family md-name &key (global-search t))
`(length (fm-find-all ,family ,md-name
:must-find nil
:global-search ,global-search)))
(defun fm-count (fm &key (test 'identity) &aux (ct 0))
(fm-traverse fm (lambda (md)
(trx counting md)
(when (funcall test md)
(incf ct))))
ct)
;---------------------------------------------------------------
(defun fm-top (fm &optional (test #'true-that) &aux (fm-parent (fm-parent fm)))
(cond ((null fm-parent) fm)
((not (funcall test fm-parent)) fm)
(t (fm-top fm-parent test))))
(defun fm-first-above (fm &key (test #'true-that) &aux (fm-parent (fm-parent fm)))
(cond ((null fm-parent) nil)
((funcall test fm-parent) fm-parent)
(t (fm-first-above fm-parent :test test))))
(defun fm-nearest-if (test fm)
(when fm
(if (funcall test fm)
fm
(fm-nearest-if test (fm-parent fm)))))
(defun fm-ancestry-do (fm fn &optional (start t))
(when start (trcx fm-ancestry-do-sees-fm fm))
(when fm
(funcall fn fm)
(fm-ancestry-do (fm-parent fm) fn nil)))
(defun fm-includes (fm sought)
(fm-ancestor-p fm sought))
(defun fm-ancestor-p (fm sought)
(c-assert fm)
(when sought
(or (eql fm sought)
(fm-includes fm (fm-parent sought)))))
(defun fm-kid-containing (fm-parent descendant)
(with-dynamic-fn (finder (node) (not (eql fm-parent node)))
(fm-top descendant finder)))
;;; above looks confused, let's try again
(defun fm-ascendant-p (older younger)
(cond
((null (fm-parent younger)) nil)
((eq older (fm-parent younger)) t)
(t (fm-ascendant-p older (fm-parent younger)))))
(defun make-name (root &optional subscript)
(if subscript (list root subscript) root))
(defun name-root (md-name)
(if (atom md-name) md-name (car md-name)))
(defun name-subscript (md-name)
(when (consp md-name) (cadr md-name)))
(defun fm-find-one (family md-name &key (must-find t)
(global-search t) skip-tree (test #'true-that)
&aux diag)
(count-it :fm-find-one)
(flet ((matcher (fm)
(when diag
(trc
"fm-find-one matcher sees name" (md-name fm) :ofthing (type-of fm) :seeking md-name global-search))
(when (and (eql (name-root md-name)(md-name fm))
(or (null (name-subscript md-name))
(eql (name-subscript md-name) (fm-pos fm)))
(progn
(when diag
(trc "fm-find-one testing" fm))
(funcall test fm)))
(throw 'fm-find-one fm))))
(trc nil "fm-find-one> entry " md-name family)
(let ((match (catch 'fm-find-one
(fm-traverse family #'matcher
:skip-tree skip-tree
:global-search global-search))))
(when (and must-find (null match))
(trc "fm-find-one > erroring fm-not-found, in family: " family :seeking md-name :global? global-search)
#+shhhh
(progn
(describe family)
(loop for h in (fm-heritage family)
do (trcx heritage-anyway h))
(setq diag t must-find nil)
(fm-traverse family #'matcher
:skip-tree skip-tree
:global-search global-search))
(c-break "fm-find-one > *stop*ping...did not find ~a ~a ~a" family md-name global-search)
)
match)))
(defun fm-find-kid (self name)
(find name (kids self) :key #'md-name))
(defun fm-kid-typed (self type)
(c-assert self)
(find type (kids self) :key #'type-of))
(defun kid-no (self)
(unless (typep self 'model-object)
(brk "not a model object ~a" self))
(when (and self (fm-parent self))
(unless (member self (kids (fm-parent self)))
(c-break "kid-no self ~a not member of kids ~a of parent ~a"
self (kids .pa) .pa))
(position self (kids (fm-parent self)))))
| 25,321 | Common Lisp | .lisp | 659 | 29.349014 | 113 | 0.557016 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | bc121cd78df80ad0ff1115f0620e984f3f23c080f77e8c1fe0ec9639167ae853 | 7,495 | [
-1
] |
7,496 | propagate.lisp | kennytilton_its-alive/lisp/propagate.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
;----------------- change detection ---------------------------------
(defun c-no-news (c new-value old-value)
;;; (trc nil "c-no-news > checking news between" newvalue oldvalue)
(bif (test (c-unchanged-test (c-model c) (c-slot-name c)))
(funcall test new-value old-value)
(eql new-value old-value)))
(defmacro def-c-unchanged-test ((class slotname) &body test)
`(defmethod c-unchanged-test ((self ,class) (slotname (eql ',slotname)))
,@test))
(defmethod c-unchanged-test (self slotname)
(declare (ignore self slotname))
nil)
; --- data pulse (change ID) management -------------------------------------
(defparameter *one-pulse?* nil)
(defparameter *data-pulse-lock* (mp:make-process-lock))
(defparameter *dp-log* nil)
(defun data-pulse-next (pulse-info)
(declare (ignorable pulse-info))
(unless *one-pulse?*
(mp:with-process-lock (*data-pulse-lock*)
#+xxxxx (when *dp-log*
(trc "dp-next> " (1+ *data-pulse-id*) pulse-info))
#+chill (when *c-debug*
(push (list :data-pulse-next pulse-info) *istack*))
(incf *data-pulse-id*))))
(defun c-currentp (c)
(eql (c-pulse c) *data-pulse-id*))
(defun c-pulse-update (c key)
(declare (ignorable key))
#+hunh?
(unless (find key '(:valid-uninfluenced))
(trc nil "!!!!!!! c-pulse-update updating !!!!!!!!!!" *data-pulse-id* c key :prior-pulse (c-pulse c)))
(unless (>= *data-pulse-id* (c-pulse c))
(describe c))
(assert (>= *data-pulse-id* (c-pulse c)) ()
"Current DP ~a not GE pulse ~a of cell ~a" *data-pulse-id* (c-pulse c) c)
(setf (c-pulse c) *data-pulse-id*))
;--------------- propagate ----------------------------
; n.b. the cell argument may have been optimized away,
; though it is still receiving final processing here.
(defparameter *per-cell-handler* nil)
(defun c-propagate (c prior-value prior-value-supplied &optional (callers (c-callers c)))
(when *one-pulse?*
(when *per-cell-handler*
(funcall *per-cell-handler* c prior-value prior-value-supplied)
(return-from c-propagate)))
(count-it :cpropagate)
(setf (c-pulse-last-changed c) *data-pulse-id*)
(let (*depender* *call-stack* ;; I think both need clearing, cuz we are neither depending nor calling when we prop to callers
(*c-prop-depth* (1+ *c-prop-depth*))
(*defer-changes* t))
(trc nil "c.propagate clearing *depender*" c)
;------ debug stuff ---------
;
(when *stop*
(princ #\.)(princ #\!)
(return-from c-propagate))
(trc nil "c.propagate> !!!!!!! propping" c (c-value c) :caller-ct (length (c-callers c)))
#+slow (trc nil "c.propagate> !!!! new value" (c-value c) :prior-value prior-value :caller-ct (length (c-callers c)) c)
(when *c-debug*
(when (> *c-prop-depth* 250)
(trc nil "c.propagate deep" *c-prop-depth* (c-model c) (c-slot-name c) #+nah c))
(when (> *c-prop-depth* 300)
(c-break "c.propagate looping ~c" c)))
; --- manifest new value as needed ---
;
; 20061030 Trying not.to.be first because doomed instances may be interested in callers
; who will decide to propagate. If a family instance kids slot is changing, a doomed kid
; will be out of the kids but not yet quiesced. If the propagation to this rule asks the kid
; to look at its siblings (say a view instance being deleted from a stack who looks to the psib
; pb to decide its own pt), the doomed kid will still have a parent but not be in its kids slot
; when it goes looking for a sibling relative to its position.
;
(when (and prior-value
(md-slot-owning? (type-of (c-model c)) (c-slot-name c)))
(trc nil "c.propagate> contemplating lost" (qci c))
(b-when lost (#-bammd set-difference #+bammd stable-set-difference (list! prior-value) (list! (c-value c)))
(trc nil "prop nailing owned!!!!!!!!!!!" (qci c) :lost (length lost))
(map nil 'not-to-be lost)))
; propagation to callers jumps back in front of client slot--value-observe handling in cells3
; because model adopting (once done by the kids change handler) can now be done in
; shared-initialize (since one is now forced to supply the parent to make-instance).
;
; we wnat it here to support (eventually) state change rollback. change handlers are
; expected to have side-effects, so we want to propagate fully and be sure no rule
; wants a rollback before starting with the side effects.
;
(progn ;; unless (member (c-lazy c) '(t :always :once-asked)) ;; 2006-09-26 still fuzzy on this
(c-propagate-to-callers c callers))
(trc nil "c.propagate observing" c)
(when (or (> *data-pulse-id* (c-pulse-observed c))
(find (c-lazy c) '(:once-asked :always t))) ;; messy: these can get setfed/propagated twice in one pulse
;;; check this with its-alive off and see if we should check here for pulse already done
;;(trc nil ":propagate-pulsing" :*dpid* *data-pulse-id* :cdpid (c-pulse-observed c) c)
(b-if flushed (md-slot-cell-flushed (c-model c) (c-slot-name c))
(setf (flushed-cell-pulse-observed flushed) *data-pulse-id*)
(setf (c-pulse-observed c) *data-pulse-id*))
(let ((*observe-why* :propagate))
(slot-value-observe (c-slot-name c) (c-model c)
(c-value c) prior-value prior-value-supplied c)))
;
; with propagation done, ephemerals can be reset. we also do this in c-awaken, so
; let the fn decide if C really is ephemeral. Note that it might be possible to leave
; this out and use the datapulse to identify obsolete ephemerals and clear them
; when read. That would avoid ever making again bug I had in which I had the reset inside slot--value-observe,
; thinking that that always followed propagation to callers. It would also make
; debugging easier in that I could find the last ephemeral value in the inspector.
; would this be bad for persistent CLOS, in which a DB would think there was still a link
; between two records until the value actually got cleared?
;
(ephemeral-reset c)))
; --- slot change -----------------------------------------------------------
(defmacro defobserver (slotname &rest args &aux (aroundp (eq :around (first args))))
(when aroundp (setf args (cdr args)))
#+irritating
(when (find slotname '(value kids))
(warn "d: did you mean .value or .kids when you coded ~a?" slotname))
(destructuring-bind ((&optional (self-arg 'self) (new-varg 'new-value)
(oldvarg 'old-value) (oldvargboundp 'old-value-boundp) (cell-arg 'c))
&body output-body) args
`(progn
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf (get ',slotname :output-defined) t))
,(if (eql (last1 output-body) :test)
(let ((temp1 (gensym))
(loc-self (gensym)))
`(defmethod slot-value-observe #-(or cormanlisp) ,(if aroundp :around 'progn)
((slotname (eql ',slotname)) ,self-arg ,new-varg ,oldvarg ,oldvargboundp ,cell-arg)
(let ((,temp1 (bump-output-count ,slotname))
(,loc-self ,(if (listp self-arg)
(car self-arg)
self-arg)))
(when (and ,oldvargboundp ,oldvarg)
(format t "~&output ~d (~a ~a) old: ~a" ,temp1 ',slotname ,loc-self ,oldvarg ,cell-arg))
(format t "~&output ~d (~a ~a) new: ~a" ,temp1 ',slotname ,loc-self ,new-varg ,cell-arg))))
`(defmethod slot-value-observe
#-(or cormanlisp) ,(if aroundp :around 'progn)
((slotname (eql ',slotname)) ,self-arg ,new-varg ,oldvarg ,oldvargboundp ,cell-arg)
(declare (ignorable
,@(flet ((arg-name (arg-spec)
(etypecase arg-spec
(list (car arg-spec))
(atom arg-spec))))
(list (arg-name self-arg)(arg-name new-varg)
(arg-name oldvarg)(arg-name oldvargboundp) (arg-name cell-arg)))))
,@output-body)))))
(defmacro dbgobserver (slotname &optional params &body body)
`(defobserver ,slotname ,params
(trcx ,(conc$ 'obs- slotname) self (md-name self) new-value old-value old-value-boundp c)
,@body))
(export! dbgobserver)
(defmacro bump-output-count (slotname) ;; pure test func
`(if (get ',slotname :outputs)
(incf (get ',slotname :outputs))
(setf (get ',slotname :outputs) 1)))
; --- recalculate dependents ----------------------------------------------------
(defmacro cll-outer (val &body body)
`(let ((outer-val ,val))
,@body))
(defmacro cll-inner (expr)
`(,expr outer-val))
(export! cll-outer cll-inner)
(defun c-propagate-to-callers (c callers)
;
; We must defer propagation to callers because of an edge case in which:
; - X tells A to recalculate
; - A asks B for its current value
; - B must recalculate because it too uses X
; - if B propagates to its callers after recalculating instead of deferring it
; - B might tell H to reclaculate, where H decides this time to use A
; - but A is in the midst of recalculating, and cannot complete until B returns.
; but B is busy eagerly propagating. "This time" is important because it means
; there is no way one can reliably be sure H will not ask for A
;
(when (find-if-not (lambda (caller)
(and (c-lazy caller) ;; slight optimization
(member (c-lazy caller) '(t :always :once-asked))))
callers)
(let ((causation (cons c *causation*))) ;; in case deferred
#+slow (trc nil "c.propagate-to-callers > queueing notifying callers" callers)
(with-integrity (:tell-dependents c)
(assert (null *call-stack*))
(assert (null *depender*))
;
(if (mdead (c-model c))
(trc nil "WHOAA!!!! dead by time :tell-deps dispatched; bailing" c)
(let ((*causation* causation))
(trc nil "c.propagate-to-callers > actually notifying callers of" c callers)
#+c-debug (dolist (caller callers)
(assert (find c (cd-useds caller)) () "test 1 failed ~a ~a" c caller))
#+c-debug (dolist (caller (copy-list callers)) ;; following code may modify c-callers list...
(trc nil "PRE-prop-CHECK " c :caller caller (c-state caller) (c-lazy caller))
(unless (or (eq (c-state caller) :quiesced) ;; ..so watch for quiesced
(member (c-lazy caller) '(t :always :once-asked)))
(assert (find c (cd-useds caller))() "Precheck Caller ~a of ~a does not have it as used" caller c)
))
(dolist (caller callers)
(trc nil #+chill *c-prop-dep-trace* "propagating to caller iterates" c :caller caller (c-state caller) (c-lazy caller))
(block do-a-caller
(unless (or (eq (c-state caller) :quiesced) ;; ..so watch for quiesced
(member (c-lazy caller) '(t :always :once-asked)))
(unless (find c (cd-useds caller))
(unless (c-optimized-away-p c) ;; c would have been removed from any c-useds
#+shhh (progn
(describe caller)
(describe (c-model caller))
(describe c))
(cond
((find caller (c-callers c))
(trc "WHOA!!!! Bailing on Known caller:" caller :w/out-this-callee-in-its-used c))
(t (trc nil "Bailing on caller lost during propagation:" caller :w/out-this-callee-in-its-used c)))
(return-from do-a-caller)))
#+slow (trc nil "propagating to caller is used" c :caller caller (c-currentp c))
(let ((*trc-ensure* (trcp c)))
;
; we just calculate-and-set at the first level of dependency because
; we do not need to check the next level (as ensure-value-is-current does)
; because we already know /this/ notifying dependency has changed, so yeah,
; any first-level cell /has to/ recalculate. (As for ensuring other dependents
; of the first level guy are current, that happens automatically anyway JIT on
; any read.) This is a minor efficiency enhancement since ensure-value-is-current would
; very quickly decide it has to re-run, but maybe it makes the logic clearer.
;
;(ensure-value-is-current caller :prop-from c) <- next was this, but see above change reason
;
(unless (c-currentp caller) ; happens if I changed when caller used me in current pulse
(calculate-and-set caller :propagate c))))))))))))
(defparameter *the-unpropagated* nil)
(defmacro with-one-datapulse ((&key (per-cell nil per-cell?) (finally nil finally?)) &body body)
`(call-with-one-datapulse (lambda () ,@body)
,@(when per-cell? `(:per-cell (lambda (c prior-value prior-value-boundp)
(declare (ignorable c prior-value prior-value-boundp))
,per-cell)))
,@(when finally? `(:finally (lambda (cs) (declare (ignorable cs)) ,finally)))))
(defun call-with-one-datapulse
(f &key
(per-cell (lambda (c prior-value prior-value?)
(unless (find c *the-unpropagated* :key 'car)
(pushnew (list c prior-value prior-value?) *the-unpropagated*))))
(finally (lambda (cs)
(print `(finally sees ,*data-pulse-id* ,cs))
(loop for (c prior-value prior-value?) in (nreverse cs) do
(c-propagate c prior-value prior-value?)))))
(assert (not *one-pulse?*))
(data-pulse-next :client-prop)
(trc "call-with-one-datapulse bumps pulse" *data-pulse-id*)
(funcall finally
(let ((*one-pulse?* t)
(*per-cell-handler* per-cell)
(*the-unpropagated* nil))
(funcall f)
*the-unpropagated*)))
| 14,677 | Common Lisp | .lisp | 257 | 46.754864 | 133 | 0.590909 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 242706b27434f8be0f581abf6ea9456a6c5b765bcb5b526fc88dbfe8889356ad | 7,496 | [
-1
] |
7,497 | test-cc.lisp | kennytilton_its-alive/lisp/test-cc.lisp | ;;
(in-package :cells)
(defmd tcc ()
(tccversion 1)
(tcc-a (c-in nil))
(tcc-2a (c-in nil)))
(defobserver tcc-a ()
(case (^tccversion)
(1 (when new-value
(with-cc :tcc-a-obs
(setf (tcc-2a self) (* 2 new-value))
(with-cc :aha!2
(assert (eql (tcc-2a self) (* 2 new-value))
() "one")
(trc "one happy")))
(with-cc :aha!
(assert (eql (tcc-2a self) (* 2 new-value))
() "two"))))
(2 (when new-value
(with-cc :tcc-a-obs
(setf (tcc-2a self) (* 2 new-value))
(with-cc :aha!2
(assert (eql (tcc-2a self) (* 2 new-value))
() "one")
(trc "one happy")))))))
(defun test-with-cc ()
(let ((self (make-instance 'tcc
:tccversion 2 ;:tcc-2a
)))
(trcx cool 42)
(setf (tcc-a self) 42)
(assert (eql (tcc-2a self) 84))))
#+test
(test-with-cc)
(defmd ccproc () ccp obs drv)
(defobserver ccp ()
(trcx obs-cpp new-value old-value)
(with-cc :obs-cpp
(setf (^obs) (+ (* 10 (^drv)) new-value))))
(dbgobserver obs)
(defun test-ccproc ()
(cells-reset)
(let ((x (make-instance 'ccproc
:ccp (c-in 0)
:obs (c-in 0)
:drv (c? (+ 10 (^ccp))))))
(trcx see-0-10 100 (ccp x)(drv x)(obs x))
(setf (ccp x) 1)
(trcx see-1-11-101 (ccp x)(drv x)(obs x))
(trcx now-see-1-11-101 (ccp x)(drv x)(obs x))
(setf (ccp x) 2)
(trcx see-2-12-102 (ccp x)(drv x)(obs x))
(trcx see-2-12-102 (ccp x)(drv x)(obs x))))
| 1,594 | Common Lisp | .lisp | 53 | 22.698113 | 56 | 0.494094 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 1beabe1217b53bca4d096d76fc3b0f951ade8167bd2cfb7cc3092b7511ec877c | 7,497 | [
-1
] |
7,498 | family.lisp | kennytilton_its-alive/lisp/family.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(eval-when (:compile-toplevel :execute :load-toplevel)
(export '(model value family dbg .pa par
kids kid1 .kid1 kid2 .kid2 last-kid ^k-last perishable)))
(defmodel model ()
((.md-name :cell nil :initform nil :initarg :md-name :accessor md-name)
(.fm-parent :cell nil :initform nil :initarg :fm-parent :accessor fm-parent)
;;(.dbg-par :cell nil :initform nil)
(.value :initform nil :accessor value :initarg :value)
(register? :cell nil :initform nil :initarg :register? :reader register?)
(zdbg :initform nil :accessor dbg :initarg :dbg)))
(define-symbol-macro .parent (fm-parent self))
(define-symbol-macro .pa (fm-parent self))
(defmethod md-awaken :around ((self model))
(when (eq :eternal-rest (md-state .pa))
(trcx not-awakening-child-of-dead!!!!!!!!!! self .pa)
(setf (md-state self) :eternal-rest)
(return-from md-awaken self))
(call-next-method)
self)
(defun zwibble ()
(error "value invoked on nil"))
(defmethod value ((nada null))
;; looking for tighter backtrace than method-not-found
(zwibble))
(defmethod md-finalize ((self model))
;;.bgo
(unless (or (slot-value self '.fnz)
(slot-value self '.doomed)
(eq (slot-value self '.md-state) :eternal-rest))
;(print `(:fz-not-to-be!!! ,(slot-value self '.md-name) ,(type-of self)))
(setf (slot-value self '.fnz) t)
(not-to-be self)))
(defmethod initialize-instance :after ((self model) &key)
;(excl:schedule-finalization self 'md-finalize)
(when (register? self)
(fm-register self)))
(defmethod print-cell-object ((md model))
(or (md-name md) :md?))
(defmethod fm-parent (other)
(declare (ignore other))
nil)
(defmethod (setf fm-parent) (new-value other)
(declare (ignore other))
new-value)
(defmethod print-object ((self model) s)
#+shhh (format s "~a" (type-of self))
(format s "~a~a" (if (mdead self) "DEAD!" "")
(or (md-name self) (type-of self))))
(defmethod md-name (other)
(trc "yep other md-name" other (type-of other))
other)
(defmethod md-name ((nada null))
(unless (c-stopped)
(error "md-name called on nil")
(c-stop :md-name-on-null)
(brk "md-name called on nil")))
(defmethod md-name ((sym symbol)) sym)
(defmethod shared-initialize :around ((self model) slotnames &rest initargs &key fm-parent)
(declare (ignorable initargs slotnames fm-parent))
(call-next-method)
(when (slot-boundp self '.md-name)
(unless (md-name self)
; lotsa symbols over time in a web app
;(setf (md-name self) (gentemp (string (c-class-name (class-of self)))))
(setf (md-name self) #+live (type-of self)
#-live (gensym (string (c-class-name (class-of self)))))
))
(when (and (slot-boundp self '.fm-parent)
(fm-parent self)
(zerop (adopt-ct self)))
(md-be-adopted self)))
(defmodel perishable ()
((expiration :initform nil :accessor expiration :initarg :expiration)))
(defobserver expiration ()
(when new-value
(not-to-be self)))
(defvar *parent* nil)
(defmodel family (model)
((.kid-slots :cell nil
:initform nil
:accessor kid-slots
:initarg :kid-slots)
(.kids :initform (c-in nil) ;; most useful
:owning t
:accessor kids
:initarg :kids)
(registry? :cell nil
:initform nil
:initarg :registry?
:accessor registry?)
(registry :cell nil
:initform nil
:accessor registry)))
(export! registry? )
#+test
(let ((c (find-class 'family)))
(mop::finalize-inheritance c)
(class-precedence-list c))
(defmacro the-kids (&rest kids)
`(let ((*parent* self))
(packed-flat! ,@kids)))
(defmacro c?kids (&rest kids)
`(c? (the-kids ,@kids)))
(export! c?kids .siblings)
(defmacro s-sib-no () `(position self (kids .parent)))
(define-symbol-macro .siblings (kids (fm-parent self)))
(defmacro gpar ()
`(fm-grandparent self))
(defmacro nearest (self-form type)
(let ((self (gensym)))
`(bwhen (,self ,self-form)
(if (typep ,self ',type) ,self (upper ,self ,type)))))
(defun kid1 (self) (car (kids self)))
(defun first-born-p (self)
(eq self (kid1 .parent)))
(define-symbol-macro .kid1p (first-born-p self))
(export! first-born-p .kid1p)
(defun kid2 (self) (cadr (kids self)))
(define-symbol-macro .kid1 (kid1 self))
(define-symbol-macro .kid2 (kid2 self))
(defun last-kid (self) (last1 (kids self)))
(defmacro ^k-last () `(last-kid self))
;; /// redundancy in following
(defmacro psib (&optional (self-form 'self))
(let ((self (gensym)))
`(bwhen (,self ,self-form)
(find-prior ,self (kids (fm-parent ,self))))))
(defmacro nsib (&optional (self-form 'self))
(let ((self (gensym)))
`(bwhen (,self ,self-form)
(cadr (member ,self (kids (fm-parent ,self)))))))
(define-symbol-macro .psib (psib))
(define-symbol-macro .nsib (nsib))
(export! .psib .nsib)
(defun md-be-adopted (self &aux (fm-parent (fm-parent self)) (selftype (type-of self)))
(c-assert self)
(c-assert fm-parent)
(c-assert (typep fm-parent 'family) () "fm-parent ~a offered for kid ~a not a family" fm-parent self)
(trc nil "md be adopted >" :kid self (adopt-ct self) :by fm-parent)
(when (plusp (adopt-ct self))
(c-break "2nd adopt ~a, by ~a" self fm-parent))
(incf (adopt-ct self))
(trc nil "getting adopted" self :by fm-parent)
(bwhen (kid-slots-fn (kid-slots (fm-parent self)))
(dolist (ks-def (funcall kid-slots-fn self) self)
(let ((slot-name (ks-name ks-def)))
(trc nil "got ksdef " slot-name (ks-if-missing ks-def))
(when (md-slot-cell-type selftype slot-name)
(trc nil "got cell type " slot-name )
(when (or (not (ks-if-missing ks-def))
(and (null (c-slot-value self slot-name))
(null (md-slot-cell self slot-name))))
(trc nil "ks missing ok " slot-name)
(multiple-value-bind (c-or-value suppressp)
(funcall (ks-rule ks-def) self)
(unless suppressp
(trc nil "md-install-cell " slot-name c-or-value)
(md-install-cell self slot-name c-or-value)))))))))
(defobserver .kids :around ((self family) new-kids old-kids)
(c-assert (listp new-kids) () "New kids value for ~a not listp: ~a ~a" self (type-of new-kids) new-kids)
(c-assert (listp old-kids))
(c-assert (not (member nil old-kids)))
(c-assert (not (member nil new-kids)))
(loop for newk in new-kids
unless (typep newk 'model)
do (break "family-kids-obs> non-model ~s typed ~s offered as kid to family ~a"
newk (type-of newk) self))
(loop for newk in new-kids
unless (fm-parent newk)
do (break "New as of Cells3: parent ~s must be supplied to make-instance of ~s/~s"
self newk (type-of newk)))
(call-next-method))
(defmethod kids ((other model-object)) nil)
;------------------ kid slotting ----------------------------
;
(defstruct (kid-slotdef
(:conc-name nil))
ks-name
ks-rule
(ks-if-missing t))
(defmacro mk-kid-slot ((ks-name &key if-missing) ks-rule)
`(make-kid-slotdef
:ks-name ',ks-name
:ks-rule (lambda (self)
(declare (ignorable self))
,ks-rule)
:ks-if-missing ,if-missing))
(defmacro def-kid-slots (&rest slot-defs)
`(lambda (self)
(declare (ignorable self))
(list ,@slot-defs)))
; --- registry "namespacing" ---
(defmethod registry? (other) (declare (ignore other)) nil)
(defmethod initialize-instance :after ((self family) &key)
(when (registry? self)
(assert (null (registry self)))
(setf (registry self) (make-hash-table :test 'eq))))
(defmethod fm-register (self &optional (guest self))
(assert self () "fm-register: nil self registering ~a" guest)
(if (registry? self)
(progn
(trc nil "fm-registering!!!!!!!!!!" (md-name guest) guest :with self)
(assert (registry self) () "fm-register no reg ~a" self)
(setf (gethash (md-name guest) (registry self)) guest))
(fm-register (fm-parent self) guest)))
(defmethod fm-check-out (self &optional (guest self))
(assert self () "oops ~a ~a ~a" self (fm-parent self) (slot-value self '.fm-parent))
(if (registry? self)
(progn
(assert (registry self) () "fm-check-out no reg ~a" self)
;; (trc "removing registered" (md-name guest) :from self)
(remhash (md-name guest) (registry self)))
(bif (p (fm-parent self))
(fm-check-out p guest)
(brk "oops ~a ~a ~a" self (fm-parent self) (slot-value self '.fm-parent)))))
(defmethod fm-find-registered (id self &optional (must-find? self must-find?-supplied?))
(or (if (registry? self)
(progn
(assert (registry self) () "fm-find-registered no reg ~a" self)
(or (gethash id (registry self))
(prog1 nil
(when must-find?
(loop for k being the hash-keys of (registry self)
do (print `(:seeking ,id :see-only ,k :in-registry ,self)))))))
(bwhen (p (fm-parent self))
(fm-find-registered id p must-find?)))
(when (and must-find? (not must-find?-supplied?))
(loop for k being the hash-keys of (registry (fm-ascendant-if self 'registry?))
do (print `(registered ,k)))
(error "fm-find-registered failed seeking ~a starting search at node ~a registry ~a" id self
(fm-ascendant-if self 'registry?)))))
(export! rg? rg! fm-dump-lineage)
(defmacro rg? (id)
`(fm-find-registered ,id self nil))
(defmacro rg! (id)
(if (find id '(:buddy :coach))
`(fm-other? ,id)
`(fm-find-registered ,id self)))
(defun fm-dump-lineage (self tag &optional (s t))
(when self
(print (list tag self
(when (typep self 'model)
(md-state self)) s))
(fm-dump-lineage .pa tag)) s)
| 10,001 | Common Lisp | .lisp | 249 | 34.746988 | 106 | 0.631557 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | b1d3f9a402bf377664b7c46753c753b358f4858b673f84fa57662db13d891ed3 | 7,498 | [
-1
] |
7,499 | defmodel.lisp | kennytilton_its-alive/lisp/defmodel.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(defmacro defmodel (class directsupers slotspecs &rest options)
;;(print `(defmodel sees directsupers ,directsupers using ,(or directsupers :model-object)))
(assert (not (find class directsupers))() "~a cannot be its own superclass" class)
`(progn
(setf (get ',class :cell-types) nil)
(setf (get ',class :model-ownings) nil)
(setf (get ',class 'slots-excluded-from-persistence)
(loop for slotspec in ',slotspecs
unless (and (getf (cdr slotspec) :ps t)
(getf (cdr slotspec) :persistable t))
collect (car slotspec)))
(loop for slotspec in ',slotspecs
do (destructuring-bind
(slotname &rest slotargs
&key (cell t)
&allow-other-keys)
slotspec
(declare (ignorable slotargs))
(when cell
(setf (md-slot-cell-type ',class slotname) cell))))
;; define slot macros before class so they can appear in
;; initforms and default-initargs
,@(loop for slotspec in slotspecs
nconcing (destructuring-bind
(slotname &rest slotargs
&key (cell t) (accessor slotname) reader
&allow-other-keys)
slotspec
(declare (ignorable slotargs ))
(when cell
(list (let* ((reader-fn (or reader accessor))
(deriver-fn (intern$ "^" (symbol-name reader-fn))))
`(eval-when (:compile-toplevel :execute :load-toplevel)
(unless (macro-function ',deriver-fn)
(defmacro ,deriver-fn ()
`(,',reader-fn self)))
#+sbcl (unless (fboundp ',reader-fn)
(defgeneric ,reader-fn (slot)))))))))
;
; ------- defclass --------------- (^slot-value ,model ',',slotname)
;
(prog1
(defclass ,class ,(or directsupers '(model-object)) ;; now we can def the class
,(mapcar (lambda (s)
(list* (car s)
(let ((ias (cdr s)))
(remf ias :persistable)
(remf ias :ps)
;; We handle accessor below
(when (getf ias :cell t)
(remf ias :reader)
(remf ias :writer)
(remf ias :accessor))
(remf ias :cell)
(remf ias :owning)
(remf ias :unchanged-if)
ias))) (mapcar #'copy-list slotspecs))
(:documentation
,@(or (cdr (find :documentation options :key #'car))
'("chya")))
(:default-initargs ;; nil ok and needed: acl oddity in re not clearing d-i's sans this
,@(cdr (find :default-initargs options :key #'car)))
(:metaclass ,(or (cadr (find :metaclass options :key #'car))
'standard-class)))
(defmethod shared-initialize :after ((self ,class) slot-names &rest iargs &key)
(declare (ignore slot-names iargs))
,(when (and directsupers (not (member 'model-object directsupers)))
`(unless (typep self 'model-object)
(error "If no superclass of ~a inherits directly
or indirectly from model-object, model-object must be included as a direct super-class in
the defmodel form for ~a" ',class ',class))))
;
; slot accessors once class is defined...
;
,@(mapcar (lambda (slotspec)
(destructuring-bind
(slotname &rest slotargs
&key (cell t) unchanged-if (accessor slotname) reader writer type
&allow-other-keys)
slotspec
(declare (ignorable slotargs))
(when cell
(let* ((reader-fn (or reader accessor))
(writer-fn (or writer accessor))
)
`(progn
,(when writer-fn
`(defmethod (setf ,writer-fn) (new-value (self ,class))
(setf (md-slot-value self ',slotname)
,(if type
`(coerce new-value ',type)
'new-value))))
,(when reader-fn
`(defmethod ,reader-fn ((self ,class))
(md-slot-value self ',slotname)))
,(when unchanged-if
`(def-c-unchanged-test (,class ,slotname) ,unchanged-if)))))))
slotspecs))
(loop for slotspec in ',slotspecs
do (destructuring-bind
(slotname &rest slotargs &key (cell t) owning &allow-other-keys)
slotspec
(declare (ignorable slotargs))
(when (and cell owning)
(setf (md-slot-owning-direct? ',class slotname) owning))))))
(export! defmd-canonicalize-slot)
(defun defmd-canonicalize-slot (slotname
&key
(cell nil cell-p)
(ps t ps-p)
(persistable t persistable-p)
(owning nil owning-p)
(type nil type-p)
(initform nil initform-p)
(initarg (intern (symbol-name slotname) :keyword))
(documentation nil documentation-p)
(unchanged-if nil unchanged-if-p)
(reader slotname reader-p)
(writer `(setf ,slotname) writer-p)
(accessor slotname accessor-p)
(allocation nil allocation-p))
(list* slotname :initarg initarg
(append
(when cell-p (list :cell cell))
(when ps-p (list :ps ps))
(when persistable-p (list :persistable persistable))
(when owning-p (list :owning owning))
(when type-p (list :type type))
(when initform-p (list :initform initform))
(when unchanged-if-p (list :unchanged-if unchanged-if))
(when reader-p (list :reader reader))
(when writer-p (list :writer writer))
(when (or accessor-p
(not (and reader-p writer-p)))
(list :accessor accessor))
(when allocation-p (list :allocation allocation))
(when documentation-p (list :documentation documentation)))))
(defmacro defmd (class superclasses &rest mdspec)
`(defmodel ,class (,@superclasses model)
,@(let (definitargs class-options slots)
(loop with skip
for (spec next) on mdspec
if skip
do (setf skip nil)
else do (etypecase spec
(cons
(cond
((keywordp (car spec))
(assert (find (car spec) '(:documentation :metaclass)))
(push spec class-options))
((find (cadr spec) '(:initarg :type :ps :persistable :cell :initform :allocation :reader :writer :accessor :documentation))
(push (apply 'defmd-canonicalize-slot spec) slots))
(t ;; shortform (slotname initform &rest slotdef-key-values)
(push (apply 'defmd-canonicalize-slot
(list* (car spec) :initform (cadr spec) (cddr spec))) slots))))
(keyword
(setf definitargs (append definitargs (list spec next)))
(setf skip t))
(symbol (push (list spec :initform nil
:initarg (intern (symbol-name spec) :keyword)
:accessor spec) slots)))
finally
(return (list* (nreverse slots)
(delete nil
(list* `(:default-initargs ,@definitargs)
(nreverse class-options)))))))))
#+test
(progn
(defclass md-test-super ()())
(defmd defmd-test (md-test-super)
(aaa :cell nil :initform nil :initarg :aaa :accessor aaa) ;; defmd would have written the same
(aa2 :documentation "hi mom")
bbb
(ccc 42 :allocation :class)
(ddd (c-in nil) :cell :ephemeral)
:superx 42 ;; default-initarg
(:documentation "as if!")))
| 9,136 | Common Lisp | .lisp | 182 | 31.659341 | 148 | 0.479235 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 76535c67864547c76b59b84f90cfe3348c75ad3bc2615a0c203754b9c217d004 | 7,499 | [
-1
] |
7,500 | trc-eko.lisp | kennytilton_its-alive/lisp/trc-eko.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
The Newly Cells-aware trc trace and EKO value echo facilities
|#
(in-package :cells)
;----------- trc -------------------------------------------
(defparameter *last-trc* (get-internal-real-time))
(defparameter *trcdepth* 0)
(defun trcdepth-reset ()
(setf *trcdepth* 0))
(defmacro trc (tgt-form &rest os)
(if (eql tgt-form 'nil)
'(progn)
(if (stringp tgt-form)
`(without-c-dependency
(call-trc t ,tgt-form ,@os))
(let ((tgt (gensym)))
;(brk "slowww? ~a" tgt-form)
`(without-c-dependency
(bif (,tgt ,tgt-form)
(if (trcp ,tgt)
(progn
(assert (stringp ,(car os)) () "trc with test expected string second, got ~a" ,(car os))
(call-trc t ,@os)) ;;,(car os) ,tgt ,@(cdr os)))
(progn
;(trc "trcfailed")
(count-it :trcfailed)))
(count-it :tgtnileval)))))))
(defparameter *trc-path-id* nil)
(defparameter *trc-path-id-filter* nil)
(defparameter *trc-path-max* 0)
(defparameter *trc-path-max-path* nil)
(defparameter *trc-suppress* nil)
(export! *trc-path-max* trcap)
(defmacro trcap (&rest args)
`(let (*trc-path-id-filter*)
(trc ,@args)))
(defun trc-pathp (path)
(when (> (length path) *trc-path-max*)
;;(print `(new-*trc-path-max* ,(length path) ,path))
(setf *trc-path-max* (length path)
*trc-path-max-path* path))
#+good-for-test-one
(when (> (- *trc-path-max* (length path)) 4)
(break "big path delta for new path ~s agin max ~a" path *trc-path-max-path*))
(or (null *trc-path-id-filter*)
(if (> (length path)(length *trc-path-id-filter*))
(eql 0 (search *trc-path-id-filter* path ))
(eql 0 (search path *trc-path-id-filter*)))))
(export! *trc-path-id-filter* trc-pathp *trc-suppress* trx-zero)
#-allegro-v9.0
(defun curr-thread ()
(excl:current-thread))
#+allegro-v9.0
(defun curr-thread ()
sys:*current-thread*)
(defun thread-pid ()
(or
;;#+cthread-mess
(b-when thd (curr-thread)
;(print `(thread-name ,(slot-value thd 'sys::name)))
(b-when p (slot-value thd 'sys::process)
(mp:process-os-id p)))
0))
(defun thread-name ()
;;#+cthread-mess
(b-when thd (curr-thread)
(slot-value thd 'sys::name)))
(defparameter *trx-zero* 0)
(defun trx-zero ()
(setf *trx-zero* (get-internal-real-time)))
(defun call-trc (stream s &rest os)
;; (break)
(when *trc-suppress* (return-from call-trc))
(let ((path (cond
(*trc-path-id*
(unless (trc-pathp *trc-path-id*)
(return-from call-trc))
*trc-path-id*)
((and (boundp '*trcdepth*)
*trcdepth*)
(format nil "~v,,,'.<~d~>> " (mod *trcdepth* 100) *trcdepth*))
(""))))
(format stream "~&~@[~a ~]~@[~a:~]~@[<~a> ~]~a: "
(round (- (get-internal-real-time) *trx-zero*) 100)
nil #+slow? (left$ (thread-name) 8)
nil #+xxx .dpid path))
;;(format stream " ~a " (round (- (get-internal-real-time) *last-trc*) 10))
(setf *last-trc* (get-internal-real-time))
(format stream "~a ~{~s ~}~%" s os)
(force-output stream)
(values))
(export! trx trx! brk brkx .bgo bgo *trc-path-id* ntrcx *trx-tag*)
(define-symbol-macro .bgo (brk "go"))
(defmacro bgo (msg)
`(brk "BGO ~a" ',msg))
(defmacro brkx (msg)
`(brk "At ~a: OK?" ',msg))
(defmacro trcx (tgt-form &rest os)
(if (eql tgt-form 'nil)
'(progn)
`(without-c-dependency
(call-trc t (format nil "TX[~d]> ~(~s~)"
(thread-pid) ',tgt-form)
,@(loop for obj in (or os (list tgt-form))
nconcing (list (intern (format nil "~a" obj) :keyword) obj))))))
(defmacro trx! (tag &rest os)
`(let ((*trc-suppress* nil))
(trx ,tag ,@os)))
(defparameter *trx-tag* "")
(defmacro trx (tgt-form &rest os)
(if (eql tgt-form 'nil)
'(progn)
`(without-c-dependency
(call-trc t (format nil "> ~a" ;; "TX[~a]> ~a"
;; *trx-tag* ;; (ukt::irt-mshh$)
,(string tgt-form))
,@(loop for obj in (or os (list tgt-form))
nconcing (list (intern (format nil "~a" obj) :keyword) obj))))))
(defmacro ntrcx (&rest os)
(declare (ignore os))
'(progn))
(defun call-trc-to-string (fmt$ &rest fmt-args)
(let ((o$ (make-array '(0) :element-type 'base-char
:fill-pointer 0 :adjustable t)))
(with-output-to-string (os-stream o$)
(apply 'call-trc os-stream fmt$ fmt-args))
o$))
#+findtrcevalnils
(defmethod trcp :around (other)
(unless (call-next-method other)(brk)))
(defmethod trcp (other)
(eq other t))
(defmethod trcp (($ string))
t)
(defmacro wtrc ((&optional (min 1) (max 50) &rest banner) &body body )
`(let ((*trcdepth* (if *trcdepth*
(1+ *trcdepth*)
0)))
,(when banner `(when (>= *trcdepth* ,min)
(if (< *trcdepth* ,max)
(trc ,@banner)
(progn
(brk "excess trace notttt!!! ~d" *trcdepth*) ;; ,@banner)
nil))))
(when (< *trcdepth* ,max)
,@body)))
(defmacro wtrcx ((&key (min 1) (max 50) (on? t))(&rest banner) &body body )
`(let ((*trcdepth* (if *trcdepth*
(1+ *trcdepth*)
0)))
,(when banner `(when (and (>= *trcdepth* ,min) ,on?)
(if (< *trcdepth* ,max)
(trc ,@banner)
(progn
(brk "excess trace notttt!!! ~d" *trcdepth*) ;; ,@banner)
nil))))
(when (< *trcdepth* ,max)
,@body)))
(defmacro wnotrc ((&optional (min 1) (max 50) &rest banner) &body body )
(declare (ignore min max banner))
`(progn ,@body))
;------ eko --------------------------------------
(defmacro eko ((&rest trcargs) &rest body)
(let ((result (gensym)))
`(let ((,result ,@body))
,(if (stringp (car trcargs))
`(trc ,(car trcargs) :=> ,result ,@(cdr trcargs))
`(trc ,(car trcargs) ,(cadr trcargs) :=> ,result ,@(cddr trcargs)))
,result)))
(defmacro ekx (ekx-id &rest body)
(let ((result (gensym)))
`(let ((,result (,@body)))
(trc ,(string-downcase (symbol-name ekx-id)) :=> ,result)
,result)))
(defmacro eko-if ((&rest trcargs) &rest body)
(let ((result (gensym)))
`(let ((,result ,@body))
(when ,result
(trc ,(car trcargs) :res ,result ,@(cdr trcargs)))
,result)))
(defmacro ek (label &rest body)
(let ((result (gensym)))
`(let ((,result (,@body)))
(when ,label
(trc ,label ,result))
,result)))
| 6,909 | Common Lisp | .lisp | 187 | 29.144385 | 106 | 0.527548 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 84680c83feba536f7e954f54c3eced3002f98692e00587d76cf11cd5c020ff4a | 7,500 | [
-1
] |
7,501 | test-cycle.lisp | kennytilton_its-alive/lisp/test-cycle.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
;;;
;;; Copyright (c) 1995,2003 by Kenneth William Tilton.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is furnished
;;; to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
;;; IN THE SOFTWARE.
(in-package :cells)
(defmodel m-cyc ()
((m-cyc-a :initform (c-in nil) :initarg :m-cyc-a :accessor m-cyc-a)
(m-cyc-b :initform (c-in nil) :initarg :m-cyc-b :accessor m-cyc-b)))
(def-c-output m-cyc-a ()
(print `(output m-cyc-a ,self ,new-value ,old-value))
(setf (m-cyc-b self) new-value))
(def-c-output m-cyc-b ()
(print `(output m-cyc-b ,self ,new-value ,old-value))
(setf (m-cyc-a self) new-value))
(defun m-cyc () ;;def-cell-test m-cyc
(let ((m (make-be 'm-cyc)))
(print `(start ,(m-cyc-a m)))
(setf (m-cyc-a m) 42)
(assert (= (m-cyc-a m) 42))
(assert (= (m-cyc-b m) 42))))
#+(or)
(m-cyc)
(defmodel m-cyc2 ()
((m-cyc2-a :initform (c-in 0) :initarg :m-cyc2-a :accessor m-cyc2-a)
(m-cyc2-b :initform (c? (1+ (^m-cyc2-a)))
:initarg :m-cyc2-b :accessor m-cyc2-b)))
(def-c-output m-cyc2-a ()
(print `(output m-cyc2-a ,self ,new-value ,old-value))
#+(or) (when (< new-value 45)
(setf (m-cyc2-b self) (1+ new-value))))
(def-c-output m-cyc2-b ()
(print `(output m-cyc2-b ,self ,new-value ,old-value))
(when (< new-value 45)
(setf (m-cyc2-a self) (1+ new-value))))
(def-cell-test m-cyc2
(cell-reset)
(let ((m (make-be 'm-cyc2)))
(print '(start))
(setf (m-cyc2-a m) 42)
(describe m)
(assert (= (m-cyc2-a m) 44))
(assert (= (m-cyc2-b m) 45))
))
#+(or)
(m-cyc2)
| 2,602 | Common Lisp | .lisp | 62 | 38.741935 | 84 | 0.656634 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 79939bb481f41fa61e4d7dc97525124640c985e59788408daeeb53d5d80b790b | 7,501 | [
-1
] |
7,502 | md-slot-value.lisp | kennytilton_its-alive/lisp/md-slot-value.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
Copyright (C) 1995, 2006 by Kenneth Tilton
This library is free software; you can redistribute it and/or
modify it under the terms of the Lisp Lesser GNU Public License
(http://opensource.franz.com/preamble.html), known as the LLGPL.
This library is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the Lisp Lesser GNU Public License for more details.
|#
(in-package :cells)
(defparameter *ide-app-hard-to-kill* t)
#+xxxxxx
(setf *c-bulk-max* most-positive-fixnum)
(defun md-slot-value (self slot-name &aux (c (md-slot-cell self slot-name)))
(when (mdead self)
;; we used to go kersplat in here but a problem got created just to
;; get its solution for a hint after which the whole shebang could
;; be not-to-be'd but still be interrogated for the hinting purposes
;; so... why not? The dead can still be useful.
;; If the messages get annoying do something explicit to say
;; not-to-be-but-expecting-use
;;#-gogo
;;(trcx md-slot-value-asked slot-name self)
(return-from md-slot-value (slot-value self slot-name)))
(tagbody
retry
(when *stop*
(if *ide-app-hard-to-kill*
(progn
(princ #\.)
(return-from md-slot-value))
(restart-case
(error "Cells is stopped due to a prior error.")
(continue ()
:report "Return a slot value of nil."
(return-from md-slot-value nil))
(reset-cells ()
:report "Reset cells and retry getting the slot value."
(cells-reset)
(go retry))))))
;;; (deep-probe :md-slot-value self slot-name c)
;; (count-it :md-slot-value slot-name)
(if c
(cell-read c)
(values (slot-value self slot-name) nil)))
(defun cell-read (c)
(assert (typep c 'cell))
(prog1
(with-integrity ()
(ensure-value-is-current c :c-read nil))
(when *depender*
(record-caller c))))
(defun chk (s &optional (key 'anon))
(when (mdead s)
(brk "model ~a is dead at ~a" s key)))
(defvar *trc-ensure* nil)
(defun qci (c)
(when c
(cons (md-name (c-model c)) (c-slot-name c))))
(defun ensure-value-is-current (c debug-id ensurer)
;
; ensurer can be used cell propagating to callers, or an existing caller who wants to make sure
; dependencies are up-to-date before deciding if it itself is up-to-date
;
(declare (ignorable debug-id ensurer))
(count-it! :ensure.value-is-current)
;(trc "evic entry" (qci c))
(progn ;; wtrcx (:on? nil) ("evic>" (qci c) debug-id (qci ensurer))
;(count-it! :ensure.value-is-current )
#+chill
(when ensurer ; (trcp c)
(count-it! :ensure.value-is-current (c-slot-name c) (md-name (c-model c))(c-slot-name ensurer) (md-name (c-model ensurer))))
#+chill
(when (and *c-debug* (trcp c)
(> *data-pulse-id* 650))
(bgo ens-high))
(trc nil ; c ;; (and *c-debug* (> *data-pulse-id* 495)(trcp c))
"ensure.value-is-current > entry1" debug-id (qci c) :st (c-state c) :vst (c-value-state c)
:my/the-pulse (c-pulse c) *data-pulse-id*
:current (c-currentp c) :valid (c-validp c))
#+nahhh
(when ensurer
(trc (and *c-debug* (> *data-pulse-id* 495)(trcp c))
"ensure.value-is-current > entry2"
:ensurer (qci ensurer)))
(when *not-to-be*
(when (c-unboundp c)
(error 'unbound-cell :cell c :instance (c-model c) :name (c-slot-name c)))
(return-from ensure-value-is-current
(when (c-validp c) ;; probably accomplishes nothing
(c-value c))))
(when (and (not (symbolp (c-model c))) ;; playing around with global vars and cells (where symbol is model)
(eq :eternal-rest (md-state (c-model c))))
(brk "model ~a of cell ~a is dead" (c-model c) c))
(cond
((c-currentp c)
(count-it! :ensvc-is-indeed-currentp)
(trc nil "EVIC yep: c-currentp" c)
) ;; used to follow c-inputp, but I am toying with letting ephemerals (inputs) fall obsolete
;; and then get reset here (ie, ((c-input-p c) (ephemeral-reset c))). ie, do not assume inputs are never obsolete
;;
((and (c-inputp c)
(c-validp c) ;; a c?n (ruled-then-input) cell will not be valid at first
(not (and (typep c 'c-dependent)
(eq (cd-optimize c) :when-value-t)
(null (c-value c)))))
(trc nil "evic: cool: inputp" (qci c)))
((or (bwhen (nv (not (c-validp c)))
(count-it! :ens-val-not-valid)
(trc nil "not c-validp, gonna run regardless!!!!!!" c)
nv)
;;
;; new for 2006-09-21: a cell ended up checking slots of a dead instance, which would have been
;; refreshed when checked, but was going to be checked last because it was the first used, useds
;; being simply pushed onto a list as they come up. We may need fancier handling of dead instance/cells
;; still being encountered by consulting the prior useds list, but checking now in same order as
;; accessed seems Deeply Correct (and fixed the immediate problem nicely, always a Good Sign).
;;
(labels ((some-used-changed (useds)
(when useds
(or (some-used-changed (cdr useds))
(b-when used (car useds)
(ensure-value-is-current used :nested c)
(when (> (c-pulse-last-changed used)(c-pulse c))
(count-it! :ens-val-someused-newer)
(trc nil "used changed and newer !!!!######!!!!!! used" (qci used) :oldpulse (c-pulse used)
:lastchg (c-pulse-last-changed used))
#+shhh (when (trcp c)
(describe used))
t))))))
(assert (typep c 'c-dependent))
(some-used-changed (cd-useds c))))
(unless (c-currentp c) ;; happened eg when dependent changed and its observer read this cell and updated it
(trc nil "kicking off calc-set of!!!!" (c-state c) (c-validp c) (qci c) :vstate (c-value-state c)
:stamped (c-pulse c) :current-pulse *data-pulse-id*)
(calculate-and-set c :evic ensurer)
(trc nil "kicked off calc-set of!!!!" (c-state c) (c-validp c) (qci c) :vstate (c-value-state c)
:stamped (c-pulse c) :current-pulse *data-pulse-id*)))
#+bahhhh ;; 2009-12-27 not sure on this. Idea is to keep the dead around as static data. Might be better not to let data go dead
((mdead (c-value c))
(trc "ensure.value-is-current> trying recalc of ~a with current but dead value ~a" c (c-value c))
(let ((new-v (calculate-and-set c :evic-mdead ensurer)))
(trc "ensure.value-is-current> GOT new value ~a to replace dead!!" new-v)
new-v))
(t (trc nil "ensure.current decided current, updating pulse" (c-slot-name c) debug-id)
(c-pulse-update c :valid-uninfluenced)))
(when (c-unboundp c)
(error 'unbound-cell :cell c :instance (c-model c) :name (c-slot-name c)))
(bwhen (v (c-value c))
#-gogo
(when (mdead v)
#+shhh (format t "~&on pulse ~a cell ~a value dead ~a" *data-pulse-id* c v))
v)))
(defun calculate-and-set (c dbgid dbgdata)
(declare (ignorable dbgid dbgdata)) ;; just there for inspection of the stack during debugging
(flet ((body ()
(when (c-stopped)
(princ #\.)
(return-from calculate-and-set))
#-gogo
(bwhen (x (find c *call-stack*)) ;; circularity
(unless nil ;; *stop*
(let ()
(print `(:circler ,c))
(print `(*call-stack* ,*call-stack*))
(describe c)
(trc "calculating cell:" c (cr-code c))
(trc "appears-in-call-stack (newest first): " (length *call-stack*))
(loop for caller in (copy-list *call-stack*)
for n below (length *call-stack*)
do (trc "caller> " caller #+shhh (cr-code caller))
when (eq caller c) do (loop-finish))))
(c-stop :cell-midst-askers)
(c-break ;; break is problem when testing cells on some CLs
"cell ~a midst askers (see above)" c)
(error 'asker-midst-askers :cell c))
(multiple-value-bind (raw-value propagation-code)
(calculate-and-link c)
#-gogo
(when (and *c-debug* (typep raw-value 'cell))
(c-break "new value for cell ~s is itself a cell: ~s. probably nested (c? ... (c? ))"
c raw-value))
(unless (c-optimized-away-p c)
; this check for optimized-away-p arose because a rule using without-c-dependency
; can be re-entered unnoticed since that clears *call-stack*. If re-entered, a subsequent
; re-exit will be of an optimized away cell, which we need not sv-assume on... a better
; fix might be a less cutesy way of doing without-c-dependency, and I think anyway
; it would be good to lose the re-entrance.
(md-slot-value-assume c raw-value propagation-code)))))
(if (trcp c) ;; *dbg*
(wtrc (0 100 "calcnset" c) (body))
(body))))
(defun calculate-and-link (c)
(let ((*call-stack* (cons c *call-stack*))
(*depender* c)
(*defer-changes* t))
(assert (typep c 'c-ruled))
(trc nil "calculate-and-link" c)
(cd-usage-clear-all c)
(multiple-value-prog1
(funcall (cr-rule c) c)
(c-unlink-unused c))))
;-------------------------------------------------------------
(defun md-slot-makunbound (self slot-name
&aux (c (md-slot-cell self slot-name)))
(unless c
(c-break ":md-slot-makunbound > cellular slot ~a of ~a cannot be unbound unless initialized as inputp"
slot-name self))
(when (c-unboundp c)
(return-from md-slot-makunbound nil))
(when *within-integrity* ;; 2006-02 oops, bad name
(c-break "md-slot-makunbound of ~a must be deferred by wrapping code in with-integrity" c))
;
; Big change here for Cells III: before, only the propagation was deferred. Man that seems
; wrong. So now the full makunbound processing gets deferred. Less controversially,
; by contrast the without-c-dependency wrapped everything, and while that is harmless,
; it is also unnecessary and could confuse people trying to follow the logic.
;
(let ((causation *causation*))
(with-integrity (:change c)
(let ((*causation* causation))
; --- cell & slot maintenance ---
(let ((prior-value (c-value c)))
(setf (c-value-state c) :unbound
(c-value c) nil
(c-state c) :awake)
(bd-slot-makunbound self slot-name)
;
; --- data flow propagation -----------
;
(without-c-dependency
(c-propagate c prior-value t)))))))
;;; --- setf md.slot.value --------------------------------------------------------
;;;
(defun (setf md-slot-value) (new-value self slot-name
&aux (c (md-slot-cell self slot-name)))
#+shhh (when *within-integrity*
(trc "mdsetf>" self (type-of self) slot-name :new new-value))
(when *c-debug*
(c-setting-debug self slot-name c new-value))
(trc nil "setf md-slot-value" *within-integrity* *c-debug* *defer-changes* c)
(unless c
(c-break "Non-c-in slot ~a of ~a cannot be SETFed to ~s"
slot-name self new-value))
(cond
((find (c-lazy c) '(:once-asked :always t))
(md-slot-value-assume c new-value nil)) ;; I can see :no-pragate here eventually
(*defer-changes*
(c-break "SETF of ~a must be deferred by wrapping code in WITH-INTEGRITY ~a" c *within-integrity*))
(t
(with-integrity (:change slot-name)
(md-slot-value-assume c new-value nil))))
;; new-value
;; above line commented out 2006-05-01. It seems to me we want the value assumed by the slot
;; not the value setf'ed (on rare occasions they diverge, or at least used to for delta slots)
;; anyway, if they no longer diverge the question of which to return is moot
)
(defun md-slot-value-assume (c raw-value propagation-code)
(assert c)
(trc nil "md-slot-value-assume entry" (qci c)(c-state c))
(without-c-dependency
(let ((prior-state (c-value-state c))
(prior-value (c-value c))
(absorbed-value (c-absorb-value c raw-value)))
(c-pulse-update c :slotv-assume)
; --- head off unchanged; this got moved earlier on 2006-06-10 ---
(when (and (not (eq propagation-code :propagate))
(find prior-state '(:valid :uncurrent))
(c-no-news c absorbed-value prior-value))
(setf (c-value-state c) :valid) ;; new for 2008-07-15
(trc nil "(setf md-slot-value) > early no news" propagation-code prior-state prior-value absorbed-value)
(count-it :nonews)
(return-from md-slot-value-assume absorbed-value))
; --- slot maintenance ---
(unless (c-synaptic c)
(md-slot-value-store (c-model c) (c-slot-name c) absorbed-value))
; --- cell maintenance ---
(setf
(c-value c) absorbed-value
(c-value-state c) :valid
(c-state c) :awake)
(let ((callers (copy-list (c-callers c))))
(case (and (typep c 'c-dependent)
(cd-optimize c))
((t) (c-optimize-away?! c)) ;;; put optimize test here to avoid needless linking
(:when-value-t (when (c-value c)
(c-unlink-from-used c))))
; --- data flow propagation -----------
(unless (eq propagation-code :no-propagate)
(trc nil "md-slot-value-assume flagging as changed: prior state, value:" prior-state prior-value )
(c-propagate c prior-value (cache-state-bound-p prior-state) callers))) ;; until 06-02-13 was (not (eq prior-state :unbound))
(case (and (typep c 'c-dependent)
(cd-optimize c))
((t) (c-optimize-away?! c)) ;;; put optimize test here to avoid needless linking
(:when-value-t (when (c-value c)
(c-unlink-from-used c))))
(trc nil "exiting md-slot-val-assume" (c-state c) (c-value-state c))
absorbed-value)))
(defun cache-bound-p (c)
(cache-state-bound-p (c-value-state c)))
(defun cache-state-bound-p (value-state)
(or (eq value-state :valid)
(eq value-state :uncurrent)))
;---------- optimizing away cells whose dependents all turn out to be constant ----------------
;
(defun c-optimize-away?! (c)
#+shhh (trc nil "c-optimize-away entry" (c-state c) c)
(when (and (typep c 'c-dependent)
(null (cd-useds c))
(cd-optimize c)
(not (c-optimized-away-p c)) ;; c-streams (FNYI) may come this way repeatedly even if optimized away
(c-validp c) ;; /// when would this not be the case? and who cares?
(not (c-synaptic c)) ;; no slot to cache invariant result, so they have to stay around)
(not (c-inputp c)) ;; yes, dependent cells can be inputp
)
;; (when (trcp c) (brk "go optimizing ~a" c))
#-gogo
(when (trcp c)
(trc "optimizing away" c (c-state c))
)
(count-it :c-optimized)
(setf (c-state c) :optimized-away)
(let ((entry (rassoc c (cells (c-model c)))))
(unless entry
(describe c)
(bwhen (fe (md-slot-cell-flushed (c-model c) (c-slot-name c)))
(trc "got in flushed thoi!" fe)))
(c-assert entry)
;(trc (eq (c-slot-name c) 'cgtk::id) "c-optimize-away moving cell to flushed list" c)
(setf (cells (c-model c)) (delete entry (cells (c-model c))))
;; next was eschewed on feature gogo for performance (and gc) reasons
;; but during md-awaken any absence of a cell in slot or flushed is taken to
;; mean it was a constant hence needs a one-time observe; this is a false
;; conclusion if a cell gets optimized away, so it gets observed twice in the
;; same data pulse and since observers exist to provide effects this is a Bad Thing
;; so let's
(md-cell-flush c)
)
(dolist (caller (c-callers c) )
;
; example: on window shutdown with a tool-tip displayed, the tool-tip generator got
; kicked off and asked about the value of a dead instance. That returns nil, and
; there was no other dependency, so the Cell then decided to optimize itself away.
; of course, before that time it had a normal value on which other things depended,
; so we ended up here. where there used to be a break.
;
(setf (cd-useds caller) (delete c (cd-useds caller)))
(caller-drop c caller)
;;; (trc "nested opti" c caller)
(c-optimize-away?! caller) ;; rare but it happens when rule says (or .cache ...)
)))
(export! dump-call-stack)
(defun dump-call-stack (dbgid &optional dbgdata)
(trx dump-call-stack-newest-first (length *call-stack*) dbgid dbgdata)
(loop for caller in (copy-list *call-stack*)
for n below (length *call-stack*)
do (trc "caller> " caller #+shhh (cr-code caller))))
| 17,709 | Common Lisp | .lisp | 359 | 40.192201 | 138 | 0.597977 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 75885347eafbcc80e1329e37397511c219697a522a6e57c8809f54a74be49c74 | 7,502 | [
-1
] |
7,503 | test-ephemeral.lisp | kennytilton_its-alive/lisp/test-ephemeral.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
;;;
;;; Copyright (c) 1995,2003 by Kenneth William Tilton.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is furnished
;;; to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
;;; IN THE SOFTWARE.
(in-package :cells)
(defmodel m-ephem ()
((m-ephem-a :cell :ephemeral :initform nil :initarg :m-ephem-a :accessor m-ephem-a)
(m-test-a :cell nil :initform nil :initarg :m-test-a :accessor m-test-a)
(m-ephem-b :cell :ephemeral :initform nil :initarg :m-ephem-b :accessor m-ephem-b)
(m-test-b :cell nil :initform nil :initarg :m-test-b :accessor m-test-b)))
(def-c-output m-ephem-a ()
(setf (m-test-a self) new-value))
(def-c-output m-ephem-b ()
(setf (m-test-b self) new-value))
(def-cell-test m-ephem
(let ((m (make-be 'm-ephem :m-ephem-a (c-in nil) :m-ephem-b (c? (* 2 (or (^m-ephem-a) 0))))))
(ct-assert (null (slot-value m 'm-ephem-a)))
(ct-assert (null (m-ephem-a m)))
(ct-assert (null (m-test-a m)))
(ct-assert (null (slot-value m 'm-ephem-b)))
(ct-assert (null (m-ephem-b m)))
(ct-assert (zerop (m-test-b m)))
(setf (m-ephem-a m) 3)
(ct-assert (null (slot-value m 'm-ephem-a)))
(ct-assert (null (m-ephem-a m)))
(ct-assert (eql 3 (m-test-a m)))
;
(ct-assert (null (slot-value m 'm-ephem-b)))
(ct-assert (null (m-ephem-b m)))
(ct-assert (eql 6 (m-test-b m)))
))
| 2,408 | Common Lisp | .lisp | 48 | 46.458333 | 97 | 0.67248 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | d16b5dc90f033c13c63b40a910f350dd7d83f06e7faa39429384cddc21e756cf | 7,503 | [
-1
] |
7,504 | synapse-types.lisp | kennytilton_its-alive/lisp/synapse-types.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(export! f-find)
(defmacro f-find (synapse-id sought where)
`(call-f-find ,synapse-id ,sought ,where))
(defun call-f-find (synapse-id sought where)
(with-synapse synapse-id ()
(bif (k (progn
(find sought where)))
(values k :propagate)
(values nil :no-propagate))))
(defmacro f-sensitivity (synapse-id (sensitivity &optional subtypename) &body body)
`(call-f-sensitivity ,synapse-id ,sensitivity ,subtypename (lambda () ,@body)))
(defun call-f-sensitivity (synapse-id sensitivity subtypename body-fn)
(with-synapse synapse-id (prior-fire-value)
(let ((new-value (funcall body-fn)))
;(trc "f-sensitivity fire-p decides new" new-value :from-prior prior-fire-value :sensi sensitivity)
(let ((prop-code (if (or (xor prior-fire-value new-value)
(eko (nil "sens fire-p decides" new-value prior-fire-value sensitivity)
(delta-greater-or-equal
(delta-abs (delta-diff new-value prior-fire-value subtypename)
subtypename)
(delta-abs sensitivity subtypename)
subtypename)))
:propagate
:no-propagate)))
(values (if (eq prop-code :propagate)
(progn
(trc nil "sense prior fire value now" new-value)
(setf prior-fire-value new-value))
new-value) prop-code)))))
(defmacro f-delta (synapse-id (&key sensitivity (type 'number)) &body body)
`(call-f-delta ,synapse-id ,sensitivity ',type (lambda () ,@body)))
(defun call-f-delta (synapse-id sensitivity type body-fn)
(with-synapse synapse-id (last-relay-basis last-bound-p delta-cum)
(let* ((new-basis (funcall body-fn))
(threshold sensitivity)
(tdelta (delta-diff new-basis
(if last-bound-p
last-relay-basis
(delta-identity new-basis type))
type)))
(trc nil "tdelta, threshhold" tdelta threshold)
(setf delta-cum tdelta)
(let ((propagation-code
(when threshold
(if (delta-exceeds tdelta threshold type)
(progn
(setf last-bound-p t)
(setf last-relay-basis new-basis)
:propagate)
:no-propagate))))
(trc nil "f-delta returns values" delta-cum propagation-code)
(values delta-cum propagation-code)))))
(defmacro f-plusp (key &rest body)
`(with-synapse ,key (prior-fire-value)
(let ((new-basis (progn ,@body)))
(values new-basis (if (xor prior-fire-value (plusp new-basis))
(progn
(setf prior-fire-value (plusp new-basis))
:propagate)
:no-propagate)))))
(defmacro f-zerop (key &rest body)
`(with-synapse ,key (prior-fire-value)
(let ((new-basis (progn ,@body)))
(values new-basis (if (xor prior-fire-value (zerop new-basis))
(progn
(setf prior-fire-value (zerop new-basis))
:propagate)
:no-propagate)))))
;;;(defun f-delta-list (&key (test #'true))
;;; (with-synapse (prior-list)
;;; :fire-p (lambda (syn new-list)
;;; (declare (ignorable syn))
;;; (or (find-if (lambda (new)
;;; ;--- gaining one? ----
;;; (and (not (member new prior-list))
;;; (funcall test new)))
;;; new-list)
;;; (find-if (lambda (old)
;;; ;--- losing one? ----
;;; (not (member old new-list))) ;; all olds have passed test, so skip test here
;;; prior-list)))
;;;
;;; :fire-value (lambda (syn new-list)
;;; (declare (ignorable syn))
;;; ;/// excess consing on long lists
;;; (setf prior-list (remove-if-not test new-list)))))
;;;(defun f-find-once (finder-fn)
;;; (mk-synapse (bingo bingobound)
;;;
;;; :fire-p (lambda (syn new-list)
;;; (declare (ignorable syn))
;;; (unless bingo ;; once found, yer done
;;; (setf bingobound t
;;; bingo (find-if finder-fn new-list))))
;;;
;;; :fire-value (lambda (syn new-list)
;;; (declare (ignorable syn))
;;; (or bingo
;;; (and (not bingobound) ;; don't bother if fire? already looked
;;; (find-if finder-fn new-list))))))
;;;(defun fdifferent ()
;;; (mk-synapse (prior-object)
;;; :fire-p (lambda (syn new-object)
;;; (declare (ignorable syn))
;;; (trc nil "fDiff: prior,new" (not (eql new-object prior-object))
;;; prior-object new-object)
;;; (not (eql new-object prior-object)))
;;;
;;; :fire-value (lambda (syn new-object)
;;; (declare (ignorable syn))
;;; (unless (eql new-object prior-object)
;;; (setf prior-object new-object)))
;;; ))
;;;(defun f-boolean (&optional (sensitivity 't))
;;; (f-delta :sensitivity sensitivity :type 'boolean))
| 6,094 | Common Lisp | .lisp | 120 | 40.733333 | 123 | 0.477246 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 1004b8d0097ebb558caa52f342b6e4ea2bd849d73ae6dee4466e7213e7bc658d | 7,504 | [
-1
] |
7,505 | variables.lisp | kennytilton_its-alive/lisp/variables.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
Copyright (C) 1995, 2006 by Kenneth Tilton
This library is free software; you can redistribute it and/or
modify it under the terms of the Lisp Lesser GNU Public License
(http://opensource.franz.com/preamble.html), known as the LLGPL.
This library is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the Lisp Lesser GNU Public License for more details.
|#
(in-package :cells)
(defun c-variable-accessor (symbol)
(assert (symbolp symbol))
(c-variable-reader symbol))
(defun (setf c-variable-accessor) (value symbol)
(assert (symbolp symbol))
(c-variable-writer value symbol))
(defun c-variable-reader (symbol)
(assert (symbolp symbol))
(assert (get symbol 'cell))
(cell-read (get symbol 'cell)))
(defun c-variable-writer (value symbol)
(assert (symbolp symbol))
(setf (md-slot-value nil symbol) value)
(setf (symbol-value symbol) value))
(export! def-c-variable)
(defmacro def-c-variable (v-name cell &key ephemeral owning unchanged-if)
(declare (ignore unchanged-if))
(let ((c 'whathef)) ;;(gensym)))
`(progn
(eval-when (:compile-toplevel :load-toplevel)
(define-symbol-macro ,v-name (c-variable-accessor ',v-name))
(setf (md-slot-cell-type 'null ',v-name) (when ,ephemeral :ephemeral))
(when ,owning
(setf (md-slot-owning 'null ',v-name) t)))
(eval-when (:load-toplevel)
(let ((,c ,cell))
(md-install-cell nil ',v-name ,c)
(awaken-cell ,c)))
',v-name)))
(defobserver *kenny* ()
(trcx kenny-obs new-value old-value old-value-boundp))
#+test
(def-c-variable *kenny* (c-in nil))
#+test
(defmd kenny-watcher ()
(twice (c? (bwhen (k *kenny*)
(* 2 k)))))
(defobserver twice ()
(trc "twice kenny is:" new-value self old-value old-value-boundp))
#+test-ephem
(progn
(cells-reset)
(let ((tvw (make-instance 'kenny-watcher)))
(trcx twice-read (twice tvw))
(setf *c-debug* nil)
(setf *kenny* 42)
(setf *kenny* 42)
(trcx post-setf-kenny *kenny*)
(trcx print-twice (twice tvw))
))
#+test
(let ((*kenny* 13)) (print *kenny*))
#+test
(let ((c (c-in 42)))
(md-install-cell '*test-c-variable* '*test-c-variable* c)
(awaken-cell c)
(let ((tvw (make-instance 'test-var-watcher)))
(trcx twice-read (twice tvw))
(setf *test-c-variable* 69)
(trcx print-testvar *test-c-variable*)
(trcx print-twice (twice tvw))
(unless (eql (twice tvw) 138)
(inspect (md-slot-cell tvw 'twice))
(inspect c)
))
)
#+test2
(let ((tvw (make-instance 'test-var-watcher :twice (c-in 42))))
(let ((c (c? (trcx joggggggggging!!!!!!!!!!!!!!!)
(floor (twice tvw) 2))))
(md-install-cell '*test-c-variable* '*test-c-variable* c)
(awaken-cell c)
(trcx print-testvar *test-c-variable*)
(trcx twice-read (twice tvw))
(setf (twice tvw) 138)
(trcx print-twice (twice tvw))
(trcx print-testvar *test-c-variable*)
(unless (eql *test-c-variable* 69)
(inspect (md-slot-cell tvw 'twice))
(inspect c)
))
)
| 3,247 | Common Lisp | .lisp | 94 | 30.12766 | 79 | 0.652689 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | aaff189beaf6cce48c4868dfd59b6281787b57d937d1936354ca8d4b59b61ed5 | 7,505 | [
-1
] |
7,506 | defpackage.lisp | kennytilton_its-alive/lisp/defpackage.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
;;;
;;; Copyright (c) 1995,2010 by Kenneth William Tilton.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is furnished
;;; to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
;;; IN THE SOFTWARE.
(in-package :common-lisp-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
(require :safeseq))
(defpackage :cells
(:use #:common-lisp #:utils-kt)
(:nicknames :cz)
(:import-from
;; MOP
#+allegro #:excl
#+clisp #:clos
#+cmu #:mop
#+cormanlisp #:common-lisp
#+lispworks #:clos
#+sbcl #:sb-mop
#+openmcl-partial-mop #:openmcl-mop
#+(and mcl (not openmcl-partial-mop)) #:ccl
#-(or allegro clisp cmu cormanlisp lispworks mcl sbcl)
#.(cerror "Provide a package name."
"Don't know how to find the MOP package for this Lisp.")
#:class-precedence-list
#-(and mcl (not openmcl-partial-mop)) #:class-slots
#:slot-definition-name
#:class-direct-subclasses
)
(:export #:cell #:.md-name
#:c-input #:c-in #:c-in8
#:c-formula #:c? #:c_? #:c?8 #:c?_ #:c??
#:with-integrity #:without-c-dependency #:self #:*parent*
#:.cache #:.with-c-cache #:c-lambda
#:defmodel #:defmd #:defobserver #:slot-value-observe #:def-c-unchanged-test
#:new-value #:old-value #:old-value-boundp #:c...
#:md-awaken
#:mkpart #:make-kid #:the-kids #:nsib #:value #:^value #:.value #:kids #:^kids #:.kids
#:cells-reset #:upper #:fm-max #:nearest #:fm-min-kid #:fm-max-kid #:mk-kid-slot
#:def-kid-slots #:find-prior #:fm-pos #:kid-no #:fm-includes #:fm-ascendant-common
#:fm-kid-containing #:fm-find-if #:fm-ascendant-if #:c-abs #:fm-collect-if #:psib
#:not-to-be #:ssibno
#:c-debug #:c-break #:c-assert #:c-stop #:c-stopped #:c-assert #:.stop #:delta-diff
#:wtrc #:wnotrc #:eko-if #:trc #:wtrc #:eko #:ekx #:trcp #:trcx)
#+allegro (:shadowing-import-from #:excl #:fasl-write #:fasl-read #:gc)
)
| 2,927 | Common Lisp | .lisp | 62 | 43.741935 | 90 | 0.678358 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 9d47f176595ba8e66922690f83658ae0abdb97a17a6a2484dc1455db9cd735e1 | 7,506 | [
-1
] |
7,507 | initialize.lisp | kennytilton_its-alive/lisp/initialize.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
Copyright (C) 1995, 2006 by Kenneth Tilton
|#
(in-package :cells)
(eval-when (compile eval load)
(export '(c-envalue)))
(defstruct (c-envaluer (:conc-name nil))
envalue-rule)
(defmethod awaken-cell (c)
(declare (ignorable c)))
(defmethod awaken-cell ((c cell))
(assert (c-inputp c))
;
; nothing to calculate, but every cellular slot should be output
;
(when (> *data-pulse-id* (c-pulse-observed c))
;(trc nil "awaken-pulsing" :*dpid* *data-pulse-id* :cdpid (c-pulse-observed c) c)
(setf (c-pulse-observed c) *data-pulse-id*)
(trc nil "awaken cell observing" c *data-pulse-id*)
(let ((*observe-why* :awaken-cell))
(slot-value-observe (c-slot-name c) (c-model c) (c-value c) nil nil c))
(ephemeral-reset c)))
(defmethod awaken-cell ((c c-ruled))
(let (*depender*)
(calculate-and-set c :fn-awaken-cell nil)))
#+cormanlisp ; satisfy CormanCL bug
(defmethod awaken-cell ((c c-dependent))
(let (*depender*)
(trc nil "awaken-cell c-dependent clearing *depender*" c)
(calculate-and-set c :fn-awaken-cell nil)))
(defmethod awaken-cell ((c c-drifter))
;
; drifters *begin* valid, so the derived version's test for unbounditude
; would keep (drift) rule ever from being evaluated. correct solution
; (for another day) is to separate awakening (ie, linking to independent
; cs) from evaluation, tho also evaluating if necessary during
; awakening, because awakening's other role is to get an instance up to speed
; at once upon instantiation
;
(calculate-and-set c :fn-awaken-cell nil)
(cond ((c-validp c) (c-value c))
((c-unboundp c) nil)
(t "illegal state!!!")))
| 1,768 | Common Lisp | .lisp | 45 | 35.8 | 85 | 0.68655 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | e886efe7a6a51a825cb5dc21a1b44ecb4b557302a63eacadccf71c54bb44ca07 | 7,507 | [
-1
] |
7,508 | slot-utilities.lisp | kennytilton_its-alive/lisp/slot-utilities.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(defun c-setting-debug (self slot-name c new-value)
(declare (ignorable new-value))
(cond
((null c)
(format t "c-setting-debug > constant ~a in ~a may not be altered..init to (c-in nil)"
slot-name self)
(c-break "setting-const-cell")
(error "setting-const-cell"))
((c-inputp c))
(t
(let ((self (c-model c))
(slot-name (c-slot-name c)))
;(trc "c-setting-debug sees" c newvalue self slot-name)
(when (and c (not (and slot-name self)))
;; cv-test handles errors, so don't set *stop* (c-stop)
(c-break "unadopted ~a for self ~a spec ~a" c self slot-name)
(error 'c-unadopted :cell c))
#+whocares (typecase c
(c-dependent
;(trc "setting c-dependent" c newvalue)
(format t "c-setting-debug > ruled ~a in ~a may not be setf'ed"
(c-slot-name c) self)
(c-break "setting-ruled-cell")
(error "setting-ruled-cell"))
)))))
(defun c-absorb-value (c value)
(typecase c
(c-drifter-absolute (c-value-incf c value 0)) ;; strange but true
(c-drifter (c-value-incf c (c-value c) value))
(t value)))
(eval-when (:compile-toplevel :load-toplevel :execute)
(export '(c-value-incf)))
(defmethod c-value-incf (c (envaluer c-envaluer) delta)
(c-assert (c-model c))
(c-value-incf c (funcall (envalue-rule envaluer) c)
delta))
(defmethod c-value-incf (c (base number) delta)
(declare (ignore c))
(if delta
(+ base delta)
base))
;----------------------------------------------------------------------
(defun bd-slot-value (self slot-name)
(slot-value self slot-name))
(defun (setf bd-slot-value) (new-value self slot-name)
(setf (slot-value self slot-name) new-value))
(defun bd-bound-slot-value (self slot-name caller-id)
(declare (ignorable caller-id))
(when (bd-slot-boundp self slot-name)
(bd-slot-value self slot-name)))
(defun bd-slot-boundp (self slot-name)
(slot-boundp self slot-name))
(defun bd-slot-makunbound (self slot-name)
(if slot-name ;; not in def-c-variable
(slot-makunbound self slot-name)
(makunbound self)))
#| sample incf
(defmethod c-value-incf ((base fpoint) delta)
(declare (ignore model))
(if delta
(fp-add base delta)
base))
|#
| 2,433 | Common Lisp | .lisp | 68 | 30.691176 | 91 | 0.622852 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8e1cfdcda70ff2958ee743a530ff4607d91c0f6d5ad8290eca8f8982bb5f1730 | 7,508 | [
-1
] |
7,509 | test-propagation.lisp | kennytilton_its-alive/lisp/test-propagation.lisp | ;;
(in-package :cells)
(defmd tcp ()
(left (c-in 0))
(top (c-in 0))
(right (c-in 0))
(bottom (c-in 0))
(area (c? (trc "area running")
(* (- (^right)(^left))
(- (^top)(^bottom))))))
(defobserver area ()
(trc "new area" new-value old-value old-value-boundp :pulse *data-pulse-id*))
(defobserver bottom ()
(trc "new bottom" new-value old-value old-value-boundp :pulse *data-pulse-id*)
(with-integrity (:change 'bottom-tells-left)
(setf (^left) new-value)))
(defobserver left ()
(trc "new left" new-value old-value old-value-boundp :pulse *data-pulse-id*))
(defun tcprop ()
(untrace)
(ukt:test-prep)
(let ((box (make-instance 'tcp)))
(trc "changing top to 10" *data-pulse-id*)
(setf (top box) 10)
(trc "not changing top" *data-pulse-id*)
(setf (top box) 10)
(trc "changing right to 10" *data-pulse-id*)
(setf (right box) 10)
(trc "not changing right" *data-pulse-id*)
(setf (right box) 10)
(trc "changing bottom to -1" *data-pulse-id*)
(decf (bottom box))
(with-one-datapulse ()
(loop repeat 5 do
(trc "changing bottom by -1" *data-pulse-id*)
(decf (bottom box))))))
| 1,203 | Common Lisp | .lisp | 36 | 28.527778 | 80 | 0.603986 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 737bf612b70f19869f94b5c58b1eedd2b109aa462ccdd7419603e45c094df063 | 7,509 | [
-1
] |
7,510 | cells-store.lisp | kennytilton_its-alive/lisp/cells-store.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells Store -- Dependence on a Hash-Table
Copyright (C) 2008 by Peter Hildebrandt
This library is free software; you can redistribute it and/or
modify it under the terms of the Lisp Lesser GNU Public License
(http://opensource.franz.com/preamble.html), known as the LLGPL.
This library is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the Lisp Lesser GNU Public License for more details.
|#
(in-package :cells)
(export! cells-store bwhen-c-stored c?-with-stored with-store-item store-add store-lookup store-remove store-items)
(defmacro c?-with-stored ((var key store &optional default) &body body)
`(c? (bwhen-c-stored (,var ,key ,store ,default)
,@body)))
(defmacro bwhen-c-stored ((var key store &optional if-not) &body body)
(with-gensyms (gkey gstore glink gifnot)
`(let ((,gkey ,key)
(,gstore ,store)
(,gifnot ,if-not))
(let ((,glink (query-c-link ,gkey ,gstore)))
(declare (ignorable ,glink))
(trc nil "executing bwhen-c-stored" self :update-tick ,glink :lookup (store-lookup ,gkey ,gstore))
(bif (,var (store-lookup ,gkey ,gstore))
(progn
,@body)
,gifnot)))))
(defmodel cells-store (family)
((data :accessor data :initarg :data :cell nil))
(:default-initargs
:data (make-hash-table)))
;;; infrastructure for manipulating the store and kicking rules
(defmethod entry (key (store cells-store))
(gethash key (data store)))
(defmethod (setf entry) (new-data key (store cells-store))
(setf (gethash key (data store)) new-data))
(defmethod c-link (key (store cells-store))
(car (entry key store)))
(defmethod (setf c-link) (new-c-link key (store cells-store))
(if (consp (entry key store))
(setf (car (entry key store)) new-c-link)
(setf (entry key store) (cons new-c-link nil)))
new-c-link)
(defmethod item (key (store cells-store))
(cdr (entry key store)))
(defmethod (setf item) (new-item key (store cells-store))
(if (consp (entry key store))
(setf (cdr (entry key store)) new-item)
(setf (entry key store) (cons nil new-item)))
new-item)
;;; c-links
(defmodel c-link ()
((value :accessor value :initform (c-in 0) :initarg :value)))
(defmethod query-c-link (key (store cells-store))
(trc "c-link> query link" key store (c-link key store))
(value (or (c-link key store)
(setf (c-link key store) (make-instance 'c-link)))))
(defmethod kick-c-link (key (store cells-store))
(bwhen (link (c-link key store))
(trc "c-link> kick link" key store link)
(with-integrity (:change :kick-c-link)
(incf (value link)))))
(defmacro with-store-item ((item key store) &body body)
`(prog1
(symbol-macrolet ((,item '(item key store)))
(progn
,@body))
(kick-c-link ,key ,store)))
(defmacro with-store-entry ((key store &key quiet) &body body)
`(prog1
(progn
,@body)
(unless ,quiet
(kick-c-link ,key ,store))))
;;; item management
(defmethod store-add (key (store cells-store) object &key quiet)
(with-store-entry (key store :quiet quiet)
(when (item key store)
(trc "overwriting item" key (item key store)))
(setf (item key store) object)))
(defmethod store-lookup (key (store cells-store) &optional default)
(when (mdead (item key store))
(with-store-entry (key store)
(trc "looked up dead item -- resetting to nil" key store)
(setf (item key store) nil)))
(or (item key store) default))
(defmethod store-remove (key (store cells-store) &key quiet)
(with-store-entry (key store :quiet quiet)
(setf (item key store) nil)))
(defmethod store-items ((store cells-store) &key (include-keys nil))
(loop for key being the hash-keys in (data store)
for val being the hash-values in (data store)
if (and (cdr val) include-keys) collect (cons key (cdr val))
else if (cdr val) collect it))
;;; unit test
(export! test-cells-store)
(defmodel test-store-item (family)
())
(defvar *observers*)
(defobserver .value ((self test-store-item))
(trc " changed value" :self self :to (value self))
(when (boundp '*observers*)
(push self *observers*)))
(defmacro with-assert-observers ((desc &rest asserted-observers) &body body)
`(let ((*observers* nil))
(trc ,desc " -- checking observers")
,@body
(let ((superfluous-observers (loop for run in *observers* if (not (member run (list ,@asserted-observers))) collect run))
(failed-observers (loop for asserted in (list ,@asserted-observers) if (not (member asserted *observers*)) collect asserted)))
(trc "called observers on" *observers* :superflous superfluous-observers :failed failed-observers)
(assert (not superfluous-observers))
(assert (not failed-observers)))))
(defmacro assert-values ((desc) &body objects-and-values)
`(progn
(trc ,desc)
,@(loop for (obj val) in objects-and-values
collect `(assert (eql (value ,obj) ,val)))))
(defun test-cells-store ()
(trc "testing cells-store -- making objects")
(let* ((store (make-instance 'cells-store))
(foo (make-instance 'test-store-item :value (c?-with-stored (v :foo store 'nothing)
(bwhen (val (value v)) val))))
(foo+1 (make-instance 'test-store-item :value (c?-with-stored (v :foo store 'nothing)
(bwhen (val (value v)) (1+ val)))))
(bar (make-instance 'test-store-item :value (c?-with-stored (v :bar store 'nothing)
(bwhen (val (value v)) val))))
(bar-1 (make-instance 'test-store-item :value (c?-with-stored (v :bar store 'nothing)
(bwhen (val (value v)) (1- val)))))
(bypass-lookup? (make-instance 'family :value (c-in t)))
(baz (make-instance 'test-store-item :value (c? (if (value bypass-lookup?)
'no-lookup
(bwhen-c-stored (v :bar store 'nothing)
(value v)))))))
(assert-values ("assert fresh initialization")
(foo 'nothing)
(foo+1 'nothing)
(bar 'nothing)
(bar-1 'nothing))
(with-assert-observers ("adding foo" foo foo+1)
(store-add :foo store (make-instance 'family :value (c-in nil))))
(assert-values ("added foo = nil")
(foo nil)
(foo+1 nil)
(bar 'nothing)
(bar-1 'nothing))
(with-assert-observers ("changing foo" foo foo+1)
(setf (value (store-lookup :foo store)) 1))
(assert-values ("changed foo = 1")
(foo 1)
(foo+1 2)
(bar 'nothing)
(bar-1 'nothing))
(with-assert-observers ("adding bar = 42" bar bar-1)
(store-add :bar store (make-instance 'family :value (c-in 42))))
(assert-values ("changed foo = 1")
(foo 1)
(foo+1 2)
(bar 42)
(bar-1 41))
(with-assert-observers ("changing bar to 2" bar bar-1)
(setf (value (store-lookup :bar store)) 2))
(assert-values ("changed foo = 1")
(foo 1)
(foo+1 2)
(bar 2)
(bar-1 1))
(assert-values ("baz w/o lookup")
(baz 'no-lookup))
(with-assert-observers ("activating lookup" baz)
(setf (value bypass-lookup?) nil))
(assert-values ("baz w/lookup")
(baz 2))
(with-assert-observers ("deleting foo" foo foo+1)
(store-remove :foo store))
(assert-values ("deleted foo")
(foo 'nothing)
(foo+1 'nothing)
(bar 2)
(bar-1 1))
(with-assert-observers ("deleting bar" bar bar-1 baz)
(store-remove :bar store))
(assert-values ("deleted bar")
(foo 'nothing)
(foo+1 'nothing)
(bar 'nothing)
(bar-1 'nothing)
(baz 'nothing))
(with-assert-observers ("de-activating lookup" baz)
(setf (value bypass-lookup?) t))
(assert-values ("baz w/o lookup")
(baz 'no-lookup)))) | 7,794 | Common Lisp | .lisp | 192 | 35.546875 | 130 | 0.651008 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 33db95f51d4b21845d3f1d0b7074966ca9eafd6e73d67879b1ae75fdc34ffc70 | 7,510 | [
-1
] |
7,511 | link.lisp | kennytilton_its-alive/lisp/link.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
Copyright (C) 1995, 2006 by Kenneth Tilton
|#
(in-package :cells)
(defun record-caller (used)
(assert used)
(when (c-optimized-away-p used) ;; 2005-05-21 removed slow type check that used is cell
(trc nil "depender not being recorded because used optimized away" *depender* (c-value used) :used used)
(return-from record-caller nil))
#+shhh (trc *depender* "record-caller depender entry: used=" used :caller *depender*)
(assert *depender*)
#+shhh (trc used "record-caller caller entry: used=" (qci used)
:caller *depender*)
(multiple-value-bind (used-pos useds-len)
(loop with u-pos
for known in (cd-useds *depender*)
counting known into length
when (eq used known)
do
(count-it :known-used)
(setf u-pos length)
finally (return (values (when u-pos (- length u-pos)) length)))
(when (null used-pos)
(trc nil "c-link > new caller,used " *depender* used)
(count-it :new-used)
(setf used-pos useds-len)
(push used (cd-useds *depender*))
(caller-ensure used *depender*) ;; 060604 experiment was in unlink
)
(when (c-debug *depender*)
(trx rec-caller-sets-usage!!!!!!!!!!!!!!!!!!!! *depender* used used-pos))
(set-usage-bit *depender* used-pos)
)
used)
(defun set-usage-bit (c n) ;; c is caller
;(trc c "set-usage-bit entry!!!!" c n (array-dimension (cd-usage c) 0))
#+xxxx(when (> n 32)
(loop for u in (cd-useds c)
do (trc "sub-used" u))
(trc "set-usage-bit entry > 10!!!!" c n (array-dimension (cd-usage c) 0)))
(unless (< n (array-dimension (cd-usage c) 0))
;(trc c "set-usage-bit growing!!!!!" c n (+ n 16))
(setf (cd-usage c)(adjust-array (cd-usage c) (+ n 16) :initial-element 0)))
(setf (sbit (cd-usage c) n) 1))
;--- unlink unused --------------------------------
(defun c-unlink-unused (c &aux (usage (cd-usage c))
(usage-size (array-dimension (cd-usage c) 0))
(dbg nil))
(declare (ignorable dbg usage-size))
(when (cd-useds c)
(let (rev-pos)
(labels ((nail-unused (useds)
(flet ((handle-used (rpos)
(if (or (>= rpos usage-size)
(zerop (sbit usage rpos)))
(progn
(count-it :unlink-unused)
(trc nil "c-unlink-unused" c :dropping-used (car useds))
(c-unlink-caller (car useds) c)
(rplaca useds nil))
(progn
;; moved into record-caller 060604 (caller-ensure (car useds) c)
)
)))
(if (cdr useds)
(progn
(nail-unused (cdr useds))
(handle-used (incf rev-pos)))
(handle-used (setf rev-pos 0))))))
(trc nil "cd-useds length" (length (cd-useds c)) c)
(nail-unused (cd-useds c))
(setf (cd-useds c) (delete nil (cd-useds c)))
(trc nil "useds of" c :now (mapcar 'qci (cd-useds c)))))))
(defun c-caller-path-exists-p (from-used to-caller)
(count-it :caller-path-exists-p)
(or (find to-caller (c-callers from-used))
(find-if (lambda (from-used-caller)
(c-caller-path-exists-p from-used-caller to-caller))
(c-callers from-used))))
; ---------------------------------------------
(defun cd-usage-clear-all (c)
(setf (cd-usage c) (blank-usage-mask)))
;--- unlink from used ----------------------
(defmethod c-unlink-from-used ((caller c-dependent))
(dolist (used (cd-useds caller))
(trc nil "unlinking from used" caller used)
(c-unlink-caller used caller))
;; shouldn't be necessary (setf (cd-useds caller) nil)
)
(defmethod c-unlink-from-used (other)
(declare (ignore other)))
;----------------------------------------------------------
(defun c-unlink-caller (used caller)
(trc nil "(1) caller unlinking from (2) used" caller used)
(caller-drop used caller)
(c-unlink-used caller used))
(defun c-unlink-used (caller used)
(setf (cd-useds caller) (delete used (cd-useds caller))))
;----------------- link debugging ---------------------
(defun dump-callers (c &optional (depth 0))
(format t "~&~v,4t~s" depth c)
(dolist (caller (c-callers c))
(dump-callers caller (+ 1 depth))))
(defun dump-useds (c &optional (depth 0))
;(c.trc "dump-useds> entry " c (+ 1 depth))
(when (zerop depth)
(format t "x~&"))
(format t "~&|usd> ~v,8t~s" depth c)
(when (typep c 'c-ruled)
;(c.trc "its ruled" c)
(dolist (used (cd-useds c))
(dump-useds used (+ 1 depth)))))
| 5,000 | Common Lisp | .lisp | 114 | 34.429825 | 108 | 0.538446 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | a12f46446f7640323b263cc2b77c8e51f9f87ee0f0cff61ae15c71a5e3947592 | 7,511 | [
-1
] |
7,512 | test.lisp | kennytilton_its-alive/lisp/test.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
;;;
;;; Copyright (c) 1995,2003 by Kenneth William Tilton.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is furnished
;;; to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
;;; IN THE SOFTWARE.
#| Synapse Cell Unification Notes
- start by making Cells synapse-y
- make sure outputs show right old and new values
- make sure outputs fire when they should
- wow: test the Cells II dictates: no output callback sees stale data, no rule
sees stale data, etc etc
- test a lot of different synapses
- make sure they fire when they should, and do not when they should not
- make sure they survive an evaluation by the caller which does not branch to
them (ie, does not access them)
- make sure they optimize away
- test with forms which access multiple other cells
- look at direct alteration of a caller
- does SETF honor not propagating, as well as a c-ruled after re-calcing
- do diff unchanged tests such as string-equal work
|#
#| do list
-- can we lose the special handling of the .kids slot?
-- test drifters (and can they be handled without creating a special
subclass for them?)
|#
(eval-when (compile load)
(proclaim '(optimize (speed 2) (safety 3) (space 1) (debug 3))))
(in-package :cells)
(defvar *cell-tests* nil)
#+go
(test-cells)
(defun test-cells ()
(loop for test in (reverse *cell-tests*)
do (cell-test-init test)
(funcall test)))
(defun cell-test-init (name)
(print (make-string 40 :initial-element #\!))
(print `(starting test ,name))
(print (make-string 40 :initial-element #\!))
(cell-reset))
(defmacro def-cell-test (name &rest body)
`(progn
(pushnew ',name *cell-tests*)
(defun ,name ()
(cell-reset)
,@body)))
(defmacro ct-assert (form &rest stuff)
`(progn
(print `(attempting ,',form))
(assert ,form () "Error with ~a >> ~a" ',form (list ,@stuff))))
;; test huge number of useds by one rule
(defmodel m-index (family)
()
(:default-initargs
:value (c? (bwhen (ks (^kids))
(apply '+ (mapcar 'value ks))))))
(def-cell-test many-useds
(let ((i (make-instance 'm-index)))
(loop for n below 100
do (push (make-instance 'model
:value (c-in n))
(kids i)))
(trc "index total" (value i))))
(defmodel m-null ()
((aa :initform nil :cell nil :initarg :aa :accessor aa)))
(def-cell-test m-null
(let ((m (make-be 'm-null :aa 42)))
(ct-assert (= 42 (aa m)))
(ct-assert (= 21 (decf (aa m) 21)))
:okay-m-null))
(defmodel m-solo ()
((m-solo-a :initform nil :initarg :m-solo-a :accessor m-solo-a)
(m-solo-b :initform nil :initarg :m-solo-b :accessor m-solo-b)))
(def-cell-test m-solo
(let ((m (make-be 'm-solo
:m-solo-a (c-in 42)
:m-solo-b (c? (* 2 (^m-solo-a))))))
(ct-assert (= 42 (m-solo-a m)))
(ct-assert (= 84 (m-solo-b m)))
(decf (m-solo-a m))
(ct-assert (= 41 (m-solo-a m)))
(ct-assert (= 82 (m-solo-b m)))
:okay-m-null))
(defmodel m-var ()
((m-var-a :initform nil :initarg :m-var-a :accessor m-var-a)
(m-var-b :initform nil :initarg :m-var-b :accessor m-var-b)))
(def-c-output m-var-b ()
(print `(output m-var-b ,self ,new-value ,old-value)))
(def-cell-test m-var
(let ((m (make-be 'm-var :m-var-a (c-in 42) :m-var-b 1951)))
(ct-assert (= 42 (m-var-a m)))
(ct-assert (= 21 (decf (m-var-a m) 21)))
(ct-assert (= 21 (m-var-a m)))
:okay-m-var))
(defmodel m-var-output ()
((cbb :initform nil :initarg :cbb :accessor cbb)
(aa :cell nil :initform nil :initarg :aa :accessor aa)))
(def-c-output cbb ()
(trc "output cbb" self)
(setf (aa self) (- new-value (if old-value-boundp
old-value 0))))
(def-cell-test m-var-output
(let ((m (make-be 'm-var-output :cbb (c-in 42))))
(ct-assert (eql 42 (cbb m)))
(ct-assert (eql 42 (aa m)))
(ct-assert (eql 27 (decf (cbb m) 15)))
(ct-assert (eql 27 (cbb m)))
(ct-assert (eql -15 (aa m)))
(list :okay-m-var (aa m))))
(defmodel m-var-linearize-setf ()
((ccc :initform nil :initarg :ccc :accessor ccc)
(ddd :initform nil :initarg :ddd :accessor ddd)))
(def-c-output ccc ()
(with-deference
(setf (ddd self) (- new-value (if old-value-boundp
old-value 0)))))
(def-cell-test m-var-linearize-setf
(let ((m (make-be 'm-var-linearize-setf
:ccc (c-in 42)
:ddd (c-in 1951))))
(ct-assert (= 42 (ccc m)))
(ct-assert (= 42 (ddd m)))
(ct-assert (= 27 (decf (ccc m) 15)))
(ct-assert (= 27 (ccc m)))
(ct-assert (= -15 (ddd m)))
:okay-m-var))
;;; -------------------------------------------------------
(defmodel m-ruled ()
((eee :initform nil :initarg :eee :accessor eee)
(fff :initform (c? (floor (^ccc) 2)) :initarg :fff :accessor fff)))
(def-c-output eee ()
(print `(output> eee ,new-value old ,old-value)))
(def-c-output fff ()
(print `(output> eee ,new-value old ,old-value)))
(def-cell-test m-ruled
(let ((m (make-be 'm-ruled
:eee (c-in 42)
:fff (c? (floor (^eee) 2)))))
(trc "___Initial TOBE done____________________")
(print `(pulse ,*data-pulse-id*))
(ct-assert (= 42 (eee m)))
(ct-assert (= 21 (fff m)))
(ct-assert (= 36 (decf (eee m) 6)))
(print `(pulse ,*data-pulse-id*))
(ct-assert (= 36 (eee m)))
(ct-assert (= 18 (fff m)) m)
:okay-m-ruled))
(defmodel m-worst-case ()
((wc-x :accessor wc-x :initform (c-input () 2))
(wc-a :accessor wc-a :initform (c? (when (oddp (wc-x self))
(wc-c self))))
(wc-c :accessor wc-c :initform (c? (evenp (wc-x self))))
(wc-h :accessor wc-h :initform (c? (or (wc-c self)(wc-a self))))))
(def-cell-test m-worst-case
(let ((m (make-be 'm-worst-case)))
(trc "___Initial TOBE done____________________")
(ct-assert (eql t (wc-c m)))
(ct-assert (eql nil (wc-a m)))
(ct-assert (eql t (wc-h m)))
(ct-assert (eql 3 (incf (wc-x m))))))
| 7,107 | Common Lisp | .lisp | 177 | 35.186441 | 84 | 0.610036 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 22c755f50f5093603e6f0e001559d321bf5b880db7bb74854116f2117f92c411 | 7,512 | [
-1
] |
7,513 | integrity.lisp | kennytilton_its-alive/lisp/integrity.lisp | ;; -*- mode: Lisp; Syntax: Common-Lisp; Package: cells; -*-
#|
Cells -- Automatic Dataflow Managememnt
|#
(in-package :cells)
(define-constant *ufb-opcodes* '(:tell-dependents
:awaken
:client
:ephemeral-reset
:change
:post-change))
(defmacro with-integrity ((&optional opcode defer-info debug) &rest body)
(declare (ignorable debug))
(when opcode
(assert (find opcode *ufb-opcodes*) ()
"Invalid opcode for with-integrity: ~a. Allowed values: ~a" opcode *ufb-opcodes*))
`(call-with-integrity ,opcode ,defer-info
(lambda (opcode defer-info)
(declare (ignorable opcode defer-info))
;;; ,(when debug
;;; `(trc "integrity action entry" opcode defer-info ',body))
;;; (when *c-debug*
#+shhh (when (eq opcode :change)
(trc "-------w/integ :change go--------------->:" defer-info))
,@body)
nil
#+noway (when *c-debug* ',body)))
(export! with-cc without-integrity)
(defmacro with-cc (id &body body)
`(with-integrity (:change ,id)
;;(print `(with-cc-fires!!!!!!!!!! ,',id))
,@body))
(defun integrity-managed-p ()
*within-integrity*)
(defmacro without-integrity (&body body)
`(let (*within-integrity* *defer-changes* *call-stack*)
,@body))
(defun call-with-integrity (opcode defer-info action code)
(declare (ignorable code))
(when *stop*
(print :cwi-sees-stop!!!!!!!!!!!)
(return-from call-with-integrity))
(if *within-integrity*
(if opcode
(prog1
:deferred-to-ufb-1 ; SETF is supposed to return the value being installed
; in the place, but if the SETF is deferred we return
; something that will help someone who tries to use
; the setf'ed value figure out what is going on:
(ufb-add opcode (cons defer-info action)))
; thus by not supplying an opcode one can get something
; executed immediately, potentially breaking data integrity
; but signifying by having coded the with-integrity macro
; that one is aware of this. If you have read this comment.
(funcall action opcode defer-info))
(flet ((go-go ()
(let ((*within-integrity* t)
*unfinished-business*
*finbiz-id*
*defer-changes*)
(trc nil "initiating new UFB!!!!!!!!!!!!" opcode defer-info)
;(when *c-debug* (assert (boundp '*istack*)))
(when (or (zerop *data-pulse-id*)
(eq opcode :change))
(eko (nil "!!! New pulse, event" *data-pulse-id* defer-info)
(data-pulse-next (cons opcode defer-info))))
(prog1
(funcall action opcode defer-info)
(let ((*finbiz-id* 0))
;(print :finishing-business)
(finish-business)
(assert-ufb-all-empty)
;; (assert-ufb-q-empty :tell-dependents)
;; (assert-ufb-q-empty :change)
)))))
(if nil ;; *c-debug*
(let ((*istack* (list (list opcode defer-info)
(list :trigger code)
(list :start-dp *data-pulse-id*))))
(trc "*istack* bound")
(handler-case
(go-go)
(xcell (c)
(if (functionp *c-debug*)
(funcall *c-debug* c (nreverse *istack*))
(loop for f in (nreverse *istack*)
do (format t "~&istk> ~(~a~) " f)
finally (describe c)
(brk "integ backtrace: see listener for deets")))))
(trc "*istack* unbinding"))
(go-go)))))
(defun ufb-queue (opcode)
(cdr (assoc opcode *unfinished-business*)))
(defun ufb-queue-ensure (opcode)
#-live (assert (find opcode *ufb-opcodes*))
(or (ufb-queue opcode)
(cdr (car (push (cons opcode (make-fifo-queue)) *unfinished-business*)))))
(defparameter *no-tell* nil)
(defun ufb-add (opcode continuation)
#+trythis (when (and *no-tell* (eq opcode :tell-dependents))
(brk "truly queueing tell under no-tell"))
(trc nil "ufb-add deferring" opcode (when (eql opcode :client)(car continuation)))
(fifo-add (ufb-queue-ensure opcode) continuation))
(defparameter *just-do-it-q* nil)
(defun just-do-it (op-or-q &optional (op-code op-or-q) ;; [mb]
&aux (q (if (keywordp op-or-q)
(ufb-queue op-or-q)
op-or-q)))
(declare (ignorable op-code))
(let ((*just-do-it-q* op-or-q)) ;; debug aid
(trc nil "----------------------------just do it doing---------------------" op-or-q)
(loop for (defer-info . task) = (fifo-pop q)
while task
do (trc nil "unfin task is" opcode task)
#+chill (when *c-debug*
(push (list op-code defer-info) *istack*))
(funcall task op-or-q defer-info))))
(defun assert-ufb-all-empty ()
#-live
(loop for (opcode . nil) in *unfinished-business*
do (assert-ufb-q-empty opcode)))
(defun assert-ufb-q-empty (q)
(declare (ignorable q))
#-live
(bwhen (uqp (fifo-peek (ufb-queue q)))
(print `(assert-ufb-q-empty-fail ,q ,uqp))
(dolist (b (fifo-data (ufb-queue q)))
(trc "assert-ufb-q-empty sees unhandled elt" b q)
;; (trc "unhandled" q (car b) (c-callers (car b)))
)
(brk "unexpected ufb> ufb ~a remain" q)))
(defun finish-business ()
(when *stop* (return-from finish-business))
(incf *finbiz-id*)
(tagbody
tell-dependents
(just-do-it :tell-dependents)
;
; while the next step looks separate from the prior, they are closely bound.
; during :tell-dependents, any number of new model instances can be spawned.
; as they are spawned, shared-initialize queues them for awakening, which
; you will recall forces the calculation of ruled cells and observer notification
; for all cell slots. These latter may enqueue :change or :client tasks, in which
; case note that they become appended to :change or :client tasks enqueued
; during :tell-dependents. How come? Because the birth itself of model instances during
; a datapulse is considered part of that datapulse, so we do want tasks enqueued
; during their awakening to be handled along with those enqueued by cells of
; existing model instances.
;
(assert-ufb-q-empty :tell-dependents)
(let ((*no-tell* t))
(just-do-it :awaken) ;--- md-awaken new instances ---
)
;
;
; We now allow :awaken to change things so more dependents need to be told. The problem is the implicit
; dependence on the /life/ of a model whenever there is a dependence on any /cell/ of that model.
; md-quiesce currently just flags such slots as uncurrent -- maybe /that/ should change and those should
; recalculate at once -- and then an /observer/ can run and ask for a new value from such an uncurrent cell,
; which now knows it must recalculate. And that recalculation of course can and likely will come up with a new value
; and perforce need to tell its dependents. So...
;
; I /could/ explore something other than the "uncurrent" kludge, but NCTM 2007 is coming up and
; to be honest the idea of not allowing nested tells was enforcing a /guess/ that that should not
; arise, and there was not even any perceived integrity whole being closed, it was just a gratuitous
; QA trick, and indeed for a long time many nested tells were avoidable. But the case of the quiesced
; dependent reverses the arrow and puts the burden on the prosecution to prove nested tells are a problem.
(bwhen (uqp (fifo-peek (ufb-queue :tell-dependents)))
#+xxx (trc "retelling dependenst, one new one being" uqp)
(go tell-dependents))
;--- process client queue ------------------------------
;
(when *stop* (return-from finish-business))
handle-clients
(bwhen (clientq (ufb-queue :client))
(if *client-queue-handler*
(funcall *client-queue-handler* clientq) ;; might be empty/not exist, so handlers must check
(just-do-it clientq :client))
(when (fifo-peek (ufb-queue :client))
#+shhh (ukt::fifo-browse (ufb-queue :client) (lambda (entry)
(trc "surprise client" entry)))
(go handle-clients)))
;--- now we can reset ephemerals --------------------
;
; one might be wondering when the observers got notified. That happens right during
; slot.value.assume, via c-propagate.
;
; Nice historical note: by accident, in the deep-cells test to exercise the new behavior
; of cells3, I coded an ephemeral cell and initialized it to non-nil, hitting a runtime
; error (now gone) saying I had no idea what a non-nil ephemeral would mean. That had been
; my conclusion when the idea occurred to me the first time, so I stuck in an assertion
; to warn off callers.
;
; But the new
; datachange progression defined by Cells3 had already forced me to manage ephemeral resets
; more predictably (something in the test suite failed). By the time I got the runtime
; error on deep-cells I was able to confidently take out the error and just let the thing
; run. deep-cells looks to behave just right, but maybe a tougher test will present a problem?
;
(just-do-it :ephemeral-reset)
;--- do deferred state changes -----------------------
;
(bwhen (task-info (fifo-pop (ufb-queue :change)))
(trc nil "!!! finbiz --- CHANGE ---- (first of)" (fifo-length (ufb-queue :change)))
(destructuring-bind (defer-info . task-fn) task-info
(trc nil "fbz: dfrd chg" defer-info (fifo-length (ufb-queue :change)))
(data-pulse-next (list :finbiz defer-info))
(funcall task-fn :change defer-info)
;
; to finish this state change we could recursively call (finish-business), but
; a goto let's us not use the stack. Someday I envision code that keeps on
; setf-ing, polling the OS for events, in which case we cannot very well use
; recursion. But as a debugger someone might want to change the next form
; to (finish-business) if they are having trouble with a chain of setf's and
; want to inspect the history on the stack.
;
(go tell-dependents)))))
| 10,692 | Common Lisp | .lisp | 217 | 40.193548 | 120 | 0.605793 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | bce3c53bdb7974fe0c4ee5adeab5a6ff2a7f6e32d3f7b52389c75e5102422bde | 7,513 | [
-1
] |
7,532 | 01-lesson.lisp | kennytilton_its-alive/src/tiltontec/lisp/01-lesson.lisp | (defpackage #:01-lesson (:use :cl :cells))
;;
;; We will keep making new packages so we can incrementally develop the
;; same class without newer versions stomping on earlier versions (by
;; being in the same package and effectively redefining earlier versions).
;;
(in-package #:01-lesson)
#|
(xxx :initarg :xxx :initform nil :accessor xxx)
|#
(defmodel rectangle ()
((len :initarg :len :accessor len
:initform (c? (* 2 (width self))))
(width :initarg :width :initform nil :accessor width))
(:default-initargs
:width (c? (/ (len self) 2))))
(cells::ct-assert (eql 21 (width (make-instance 'rectangle :len 42)))
| 636 | Common Lisp | .lisp | 17 | 35 | 74 | 0.704731 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | db2592812ec81f92cf7cf5f1f836157630c44f25749b3588dafc79229aeb9ffb | 7,532 | [
-1
] |
7,542 | project.clj | kennytilton_its-alive/project.clj | (defproject its-alive "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.8.0"]])
| 269 | Common Lisp | .cl | 6 | 40.5 | 61 | 0.688213 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | f316e05c972664de80b8730dabdeb78708ddafd61d9e87b49605ce7de0c26c80 | 7,542 | [
-1
] |
7,544 | cells_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/cells_test.clj |
(ns tiltontec.its-alive.cells-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
))
(set! *print-level* 3)
(deftest test-input
(let [c (make-cell
:slot :mol
:value 42)]
(is (isa? ia-types (type c) ::cty/cell))
(is (= (c-value c) 42))
(is (= (c-value-state c) :valid))
(is (= #{} (c-callers c)))
(is (c-input? c))
(is (nil? (c-model c)))
(is (= :mol (c-slot c)))
))
(deftest test-c-in
(let [c (c-in 42)]
(is (isa? ia-types (type c) ::cty/cell))
(is (= (c-value c) 42))
(is (= (c-value-state c) :valid))
(is (= #{} (c-callers c)))
(is (c-input? c))
(is (c-valid? c))
(is (nil? (c-model c)))
))
(deftest test-c-in+
(let [c (c-in 42 :slot :cool)]
(is (isa? ia-types (type c) ::cty/cell))
(is (c-ref? c))
(is (= (c-value c) 42))
(is (= (c-value-state c) :valid))
(is (= #{} (c-callers c)))
(is (c-input? c))
(is (nil? (c-model c)))
(is (= :cool (c-slot c)(c-slot-name c)))
))
(deftest test-c-formula
(let [c (c? (+ 40 2))]
(is (isa? ia-types (type c) ::cty/c-formula))
(is (fn? (c-rule c)))
(is (= (c-value c) unbound))
(is (= (c-value-state c) :unbound))
(is (= #{} (c-callers c)))
(is (= #{} (c-useds c)))
(is (not (c-input? c)))
(is (nil? (c-model c)))
))
(deftest t-c?+
(let [c (c?+ (:optimize false :slot :bingo)
(trx nil :cool)
(+ 40 2))]
(is (isa? ia-types (type c) ::cty/c-formula))
(is (c-ref? c))
(is (fn? (c-rule c)))
(is (= (c-value c) unbound))
(is (= (c-value-state c) :unbound))
(is (= #{} (c-callers c)))
(is (= #{} (c-useds c)))
(is (not (c-input? c)))
(is (nil? (c-model c)))
(is (not (c-optimize c)))
(is (= :bingo (c-slot c)(c-slot-name c)))))
(deftest t-eph-1
(cells-init)
(let [boct (atom 0)
b (c-in nil
:slot :b
:obs (fn-obs (swap! boct inc))
:ephemeral? true)
crun (atom 0)
cobs (atom 0)
c (c?+ [:slot :c
:obs (fn-obs (swap! cobs inc))]
(trx nil :bingo)
(swap! crun inc)
(prog1
(str "Hi " (c-get b))
(trx nil :cellread!! @b)))]
(assert (c-rule c) "Early no rule")
(is (nil? (c-value b)))
(trx nil :valstate (c-value-state b))
(is (= :valid (c-value-state b)))
(is (c-valid? b))
(trx nil b)
(trx nil @b)
(is (c-valid? b))
(is (= "Hi " (c-get c)))
(is (= 1 @boct))
(is (= 1 @crun @cobs))
(is (nil? (:value @b)))
(do
(trx nil :first-b-reset!!!!!!!!!!!)
(c-reset! b "Mom")
(is (= "Hi Mom" (c-get c)))
(is (= 2 @boct))
(is (= 2 @crun @cobs))
(is (nil? (c-value b)))
(is (nil? (:value @b))))
(do
(trx nil :second-b-reset!!!!!!!!!!!)
(c-reset! b "Mom")
(is (= "Hi Mom" (c-get c)))
(is (= 3 @boct))
(is (= 3 @crun))
(is (= 2 @cobs))
(is (nil? (c-value b)))
(is (nil? (:value @b))))
))
(deftest t-c?n
(let [a (c-in 42 :slot :aa)
b (c?n [:slot :bb]
(/ (c-get a) 2))
c (c? (+ 1 (c-get b)))]
(is (= 21 (c-get b)))
(is (= 22 (c-get c)))
(c-reset! b 42)
(is (= 42 (c-get b)))
(is (= 43 (c-get c)))))
(deftest t-c?once
(let [a (c-in 42 :slot :aa)
b (c?once [:slot :bb]
(/ (c-get a) 2))]
(println :bbb b)
(is (= 21 (c-get b)))
(comment
(c-reset! a 2)
(is (= 2 (c-get a)))
(is (= 21 (c-get b))))))
| 3,887 | Common Lisp | .cl | 134 | 22.223881 | 64 | 0.449291 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | d2aceb251fa14faa0c6dec976428289858cb48380a083d8dd6ea88e04b62b111 | 7,544 | [
-1
] |
7,545 | utility_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/utility_test.clj | (ns tiltontec.its-alive.utility-test
(:require [clojure.test :refer :all]
[clojure.set :refer [difference]]
[tiltontec.its-alive.utility :refer :all]))
(set! *print-level* 3)
(deftest fake-cl
(is (= 42 (prog1 42 43 44)))
(is (= 42 (b-when x (+ 21 21)
x)))
(is (nil? (b-when x false
42)))
(are [lst] (= 42 (cl-find 42 lst))
'(41 42 43)
'(42 43 44)
'(40 41 42))
(is (= 42 (unless (= 2 3) 42)))
(is (nil? (unless (= 2 2) 42))))
(deftest setify
(is (= #{1 2 3} (set-ify [1 1 2 2 3 3])))
(is (= #{1 2 3} (set-ify (list 1 1 2 2 3 3))))
(is (= #{} (set-ify nil)))
(is (= #{42} (set-ify 42)))
(is (= #{"bob"} (set-ify "bob")))
(is (= #{{:a 13}} (set-ify {:a 13})))
(is (= #{42}
(difference (set-ify [1 2 42])
(set-ify (list 1 2))))))
(def-rmap-slots jj- boom)
(deftest test-rmap
(let [x (ref {:value 0 :boom 42})]
(is (= 42 (jj-boom x)))
(is (= 0 (:value @x)))
(dosync (rmap-setf [:value x] 42))
(trx nil :xxx x @x (:value @x))
(is (= 42 (:value @x)))
(is (let [j (dosync (rmap-setf [:value x] 43))]
;(trx nil :xxx x @x (:value @x))
;(trx nil :j j (type j))
(= 43 j)))
(is (= 44 (dosync (rmap-setf [:value x] 44))))
))
(deftest err-handling
(is (thrown? Exception
(err "boom")))
(is (thrown-with-msg?
Exception
#"oom"
(err "boom")))
(is (thrown-with-msg?
Exception
#"Hi mom"
(err format "Hi %s" 'mom)))
(is (any-ref? (ref 42)))
(are [x] (not (any-ref? x))
nil
42
[]
(atom 42))
(is (= "...... cool: 1, 2, 3\n:bingo\n"
(with-out-str
(binding [*trxdepth* 5]
(wtrx (0 100 "cool" 1 2 3)
(println :bingo))))))
(is (= ". test: 3\n.. test: 2\n... test: 1\n.... test: 0\n"
(with-out-str
(wtrx-test 3))))
)
(deftest fifo-build
(let [q (make-fifo-queue)]
(is (fifo-empty? q))
(is (nil? (fifo-peek q)))
(is (nil? (fifo-pop q)))
(is (empty? (fifo-data q)))
(dosync
(fifo-add q 1)
(is (not (fifo-empty? q)))
(is (= 1 (fifo-peek q)))
(is (= 1 (fifo-pop q)))
(is (fifo-empty? q)))
(dosync
(fifo-add q 1)
(fifo-add q 2)
(is (not (fifo-empty? q)))
(is (= 1 (fifo-peek q)))
(is (= 1 (fifo-pop q)))
(is (= 2 (fifo-pop q)))
(is (fifo-empty? q)))))
#_
(deftest add-x-to-y-a-using-are
(are [x y] (= 5 (add x y))
2 3
1 4
3 2))
(deftest fifo-build
(let [q (make-fifo-queue)]
(is (fifo-empty? q))
(is (nil? (fifo-peek q)))
(is (nil? (fifo-pop q)))
(is (empty? (fifo-data q)))
(dosync
(fifo-add q 1)
(is (not (fifo-empty? q)))
(is (= 1 (fifo-peek q)))
(is (= 1 (fifo-pop q)))
(is (fifo-empty? q)))
(dosync
(fifo-add q 1)
(fifo-add q 2)
(is (not (fifo-empty? q)))
(is (= 1 (fifo-peek q)))
(is (= 1 (fifo-pop q)))
(is (= 2 (fifo-pop q)))
(is (fifo-empty? q)))))
| 3,169 | Common Lisp | .cl | 113 | 21.345133 | 82 | 0.455829 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ab6d18094aac3ac4ca4928909f8b1fba957817eadaa6f70a6f11b3ed077d1709 | 7,545 | [
-1
] |
7,546 | lazy_cells_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/lazy_cells_test.clj |
(ns tiltontec.its-alive.lazy-cells-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
))
(deftest solid-lazy
(cells-init)
(let [xo (atom 0)
a (c-in 0)
x (c?_ [:obs (fn-obs (swap! xo inc))]
(+ (c-get a) 40))]
(is (= unbound (:value @x)))
(is (= 0 @xo))
(is (= 40 (c-get x)))
(is (= 1 @xo))
(c-reset! a 100)
(is (= 1 @xo))
(is (= 40 (:value @x)))
(is (= 140 (c-get x)))
(is (= 2 @xo))
))
(deftest lazy-until-asked
(cells-init)
(let [xo (atom 0)
xr (atom 0)
a (c-in 0)
x (c_? [:obs (fn-obs (swap! xo inc))]
(swap! xr inc)
(+ (c-get a) 40))]
(is (= unbound (:value @x)))
(is (= 0 @xo))
(is (= 0 @xr))
(is (= 40 (c-get x)))
(is (= 1 @xo))
(is (= 1 @xr))
(c-reset! a 100)
(is (= 2 @xo))
(is (= 2 @xr))
(is (= 140 (:value @x)))
(is (= 140 (c-get x)))
(is (= 2 @xo))
(is (= 2 @xr))
))
(deftest optimize-when-value-t
(cells-init)
(let [xo (atom 0)
xr (atom 0)
a (c-in 0 :slot :aaa)
x (c?+ [:slot :xxx
:obs (fn-obs (swap! xo inc))
:optimize :when-value-t]
(swap! xr inc)
(trx nil :reading-a!!!)
(when-let [av (c-get a)]
(when (> av 1)
(+ av 40))))]
(is (nil? (c-get x)))
(is (= #{a} (c-useds x)))
(c-reset! a 1)
(trx nil :reset-finished!!!!!!!!!!)
(is (nil? (c-get x)))
(is (= #{a} (c-useds x)))
(trx nil :reset-2-beginning!!!!!!!!!!!!)
(c-reset! a 2)
(trx nil :reset-2-finished!!!!!!!!!!)
(is (= 42 (c-get x)))
(is (empty? (c-useds x)))
(trx nil :useds (c-useds x))
(is (empty? (c-callers x)))
))
| 2,064 | Common Lisp | .cl | 73 | 20.917808 | 64 | 0.440584 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 5d0fd31ea43501e740f574643949de128eda4947372d25897634705ea98d68f1 | 7,546 | [
-1
] |
7,547 | family_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/family_test.clj | (ns tiltontec.its-alive.family-test
(:require
[clojure.test :refer :all]
;;[clojure.set :refer [difference]]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all :as cz]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.model :refer :all :as md]
[tiltontec.its-alive.family :refer :all :as fm]
))
(deftest fm-0
(cells-init)
(let [u (md/make
:kon (c-in false :slot :kon)
:kids (c? (trx :kids-run! *depender*)
(when (md-get me :kon)
(vector
(md/make
:par me
:name :konzo
:kzo (c-in 3))))))]
(is (nil? (:kids @u)))
(let [kc (md-cell u :kids)
kon (md-cell u :kon)]
(c-reset! kon true)
(is (= 1 (count (:kids @u))))
(is (fget :konzo u :inside? true))
)))
(deftest fm-1
(is (fget= :bob (ref {:name :bob})))
(is (not (fget= :bobby (ref {:name :bob}))))
(is (fget= #(do (println %)
(even? @%)) (ref 0)))
(is (not (fget= #(do (println %)
(odd? @%)) (ref 0))))
)
(deftest fm-2
(let [u (md/make
:name :uni
:kids (c? (vector
(md/make
:par me
:name :aa)
(md/make
:par me
:name :bb
:kids (c? (vector
(md/make
:par me
:name :bba)
(md/make
:par me
:name :bbb)))))))]
;; (is (fget :bba u :inside? true :must? true))
;; (is (thrown-with-msg?
;; Exception #"fget-must-failed"
;; (fget :bbax u :inside? true :must? true)))
;; (is (nil? (fget :bbax u :inside? true :must? false)))
(let [bba (fget :bba u :inside? true :must? true)]
(is bba)
(is (fm/fget :uni bba :inside? true :up? true))
(is (fget :aa bba :inside? false :up? true))
(is (fget :bb bba :inside? true :up? true))
(is (fget :bbb bba :inside? false :up? true))
)
))
(deftest fm-3
(let [u (md/make
:u63 (c? (+ (mdv! :aa :aa42)
(mdv! :bb :bb21)))
:kon (c-in false)
:kids (c? (trx :kids-run!!!!!!!!!!!! me)
(remove nil?
(vector
(md/make
:par me
:name :aa
:aa42 (c? (* 2 (mdv! :bb :bb21)))
:aa3 (c-in 3))
(when (md-get me :kon)
(md/make
:par me
:name :konzo
:kzo (c-in 3)))
(md/make
:par me
:name :bb
:bb21 (c? (* 7 (mdv! :aa :aa3))))))))]
(is (= 63 (md-get u :u63)))
(is (= 42 (mdv! :aa :aa42 u)))
(is (= 21 (mdv! :bb :bb21 u)))
(is (nil? (fget :konzo u :must? false)))
(c-reset! (md-cell u :kon) true)
(is (:kon @u))
(is (md-cell u :kon))
(is (= 3 (count (:kids @u))))
(is (fget :konzo u :inside? true))
))
(deftest fm-3x
(let [u (md/make
:u63 (c? (+ (mdv! :aa :aa42)
(mdv! :bb :bb21)))
:kon (c-in false)
:kids (c? (the-kids
(md/make
:name :aa
:aa42 (c? (* 2 (mdv! :bb :bb21)))
:aa3 (c-in 3))
(when (md-get me :kon)
(md/make
:name :konzo
:kzo (c-in 3)))
(md/make
:name :bb
:bb21 (c? (* 7 (mdv! :aa :aa3)))))))]
(is (= 63 (md-get u :u63)))
(is (= 42 (mdv! :aa :aa42 u)))
(is (= 21 (mdv! :bb :bb21 u)))
(is (nil? (fget :konzo u :must? false)))
(c-reset! (md-cell u :kon) true)
(is (:kon @u))
(is (md-cell u :kon))
(is (= 3 (count (:kids @u))))
(is (fget :konzo u :inside? true))
))
| 4,604 | Common Lisp | .cl | 127 | 21.598425 | 69 | 0.373646 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | d8c57fea7138628c2c9fba2db080474f46d17c8b6431931100f45cc1d7cdf593 | 7,547 | [
-1
] |
7,548 | model_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/model_test.clj | (ns tiltontec.its-alive.model-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.model :refer :all :as md]
[tiltontec.its-alive.family :refer :all :as fm]))
(derive cty/ia-types ::typetest ::cty/model)
(deftest mm-typed
(let [me (md/make
:type ::typetest
:x2 (c-in 2)
:age (c? (* (md-get me :x2)
21)))]
(is (= 42 (md-get me :age)))
(is (ia-type? me ::typetest))))
(deftest mm-opti-1
(let [me (md/make
:x2 2
:age (c? (* 21 (md-get me :x2)))
)]
(println :meta (meta me))
(is (= 2 (md-get me :x2)))
(is (= 42 (md-get me :age)))
(is (nil? (md-cell me :age)))
))
(deftest mm-install-alive
(let [bct (atom 0)
res (do ;; sync
(md/make
:name "Bob"
:action (c-in nil
:ephemeral? true)
:bogus (c? (if-let [be (md-get me :bogus-e)]
(do
(trx :bingo-e!!!!!!!! be @bct)
(swap! bct inc)
(* 2 be))
(trx :bogus-no-e (:bogus-e @me))))
:bogus-e (c-in 21 :ephemeral? true)
:loc (c? (case (md-get me :action)
:leave :away
:return :home
:missing))))]
(println :meta (meta res))
(is (= (:cz (meta res)) (md-cz res)))
(is (= 4 (count (md-cz res))))
(is (every? c-ref? (vals (md-cz res))))
(is (= #{:action :loc :bogus :bogus-e} (set (keys (md-cz res)))))
(is (every? #(= res (c-me %)) (vals (md-cz res))))
(is (= #{:action :loc :bogus :bogus-e}
(set (map #(c-slot %)
(vals (md-cz res))))))
(is (= "Bob" (:name @res)))
(is (= "Bob" (md-name res)))
(println :res @res)
(is (= 42 (:bogus @res)))
(is (= nil (:bogus-e @res))) ;; ephemeral, so reset to nil silently
(is (= nil (:action @res)))
(println :loc (:loc @res))
(is (= :missing (:loc @res)))
(is (= 1 @bct))
(reset! bct 0)
(md-reset! res :action :return)
(is (= :home (:loc @res)))
(is (zero? @bct))
))
(deftest hello-model
(let [uni (md/make
::fm/family
:kids (c? (the-kids
(md/make
:name :visitor
:moniker "World"
:action (c-in nil
:ephemeral? true
:obs (fn [slot me new old c]
(when new (trx visitor-did new)))))
(md/make
:name :resident
:action (c-in nil :ephemeral? true)
:location (c?+ [:obs (fn-obs (when new (trx :honey-im new)))]
(case (md-get me :action)
:leave :away
:return :home
:missing))
:response (c?+ [:obs (fn-obs (when new
(trx :r-response new)))
:ephemeral? true]
(when (= :home (md-get me :location))
(when-let [act (mdv! :visitor :action)]
(case act
:knock-knock "hello, world")))))
(md/make
:name :alarm
:on-off (c?+ [:obs (fn-obs
(trx :telling-alarm-api new))]
(if (= :home (mdv! :resident :location)) :off :on))
:activity (c?+ [:obs (fn-obs
(case new
:call-police (trx :auto-dialing-911)
nil))]
(when (= :on (md-get me :on-off))
(when-let [action (mdv! :visitor :action)]
(case action
:smashing-window :call-police
nil))))))))]
(let [viz (fm! :visitor uni)
rez (fm! :resident uni)]
(is (not (nil? viz)))
(is (not (nil? rez)))
(is (not (nil? (md-cell rez :action))))
(is (= :missing (mdv! :resident :location uni)))
(md-reset! viz :action :knock-knock)
(md-reset! viz :action :smashing-window)
(is (not (nil? (md-cell rez :action))))
(md-reset! rez :action :return)
(is (= :home (mdv! :resident :location uni)))
(md-reset! viz :action :knock-knock))))
| 5,465 | Common Lisp | .cl | 122 | 25.934426 | 89 | 0.379453 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | f8c93fddc11878e1a8263b8dc422b5d00842ee8a3ef93d02282b06b38d0a2fbb | 7,548 | [
-1
] |
7,549 | cell_types_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/cell_types_test.clj | (ns tiltontec.its-alive.cell-types-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
))
(set! *print-level* 3)
(deftest nada-much
(is (isa? ia-types ::cty/c-formula ::cty/cell)))
| 254 | Common Lisp | .cl | 7 | 31 | 64 | 0.636735 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 3635c599ece852b7947375447b014c9e2e5de6c8ee99d1a77f751048e29261dd | 7,549 | [
-1
] |
7,550 | model_base_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/model_base_test.clj | (ns tiltontec.its-alive.model-base-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
;[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.model-base :refer :all :as md]))
(deftest puh-leaze
(is (= 4 (+ 2 2))))
| 473 | Common Lisp | .cl | 10 | 38.2 | 65 | 0.616558 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 863fcc42c7a88bc8967253200c6fda9eace4440fb13f19b38563e7e6b2f8f0a0 | 7,550 | [
-1
] |
7,551 | kids_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/kids_test.clj | (ns tiltontec.its-alive.kids-test
(:require
[clojure.test :refer :all]
[clojure.set :refer [difference]]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all :as cz]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.model :refer :all :as md]
[tiltontec.its-alive.family :refer :all :as fm]
))
(deftest k-notq2be
(let [f (md/make ::fm/family
:ee (c-in 2)
:kids (c? (the-kids
(when (odd? (md-get me :ee))
(md/make
:name :yep
:value (c? (* 14 (md-get (:par @me) :ee))))))))]
(is (ia-type? f ::fm/family))
(is (empty? (md-get f :kids)))
(do
(md-reset! f :ee 3)
(is (not (empty? (md-get f :kids))))
(is (= 42 (mdv! :yep :value f)))
(let [dmw (first (md-get f :kids))]
(assert (md-ref? dmw))
(md-reset! f :ee 0)
(is (empty? (md-get f :kids)))
(trx :dmw dmw @dmw)
(is (nil? @dmw))
(is (= :dead (:state (meta dmw))))))))
| 1,249 | Common Lisp | .cl | 33 | 27.909091 | 81 | 0.500415 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | fda00c84725115deb6ac6d37e1e8a5ffb5e51079812ffc7bf02657a024c9ee59 | 7,551 | [
-1
] |
7,552 | integrity_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/integrity_test.clj |
(ns tiltontec.its-alive.integrity-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.integrity :refer :all]))
(deftest integ-1
(is (= 4 (+ 2 2))))
(defn obsdbg []
(fn-obs (trx :obsdbg slot new old (type-of c))))
(deftest obs-setf
(cells-init)
(is (zero? @+pulse+))
(do ;;binding [*dp-log* true]
(let [alarm (c-in :undefined :obs (obsdbg))
act (c-in nil :obs (obsdbg))
loc (c?+ [:obs (fn-obs (trx :loc-obs-runs!!!!)
(when-not (= new :missing)
(assert (= @+pulse+ 2))
(c-reset-next! alarm
(case new
:home :off
:away :on
(err format "unexpected loc %s" new)))))]
(case (c-get act)
:leave :away
:return :home
:missing))
alarm-speak (c?+ [:obs (fn-obs
(trx :alarm-speak (c-get act) :sees (c-get alarm) (c-get loc))
(is (= (c-get alarm) (case (c-get act)
:return :off
:leave :on
:undefined)))
(is (= +pulse+
(c-pulse act)
(c-pulse loc)
(c-pulse c))))]
(str "alarm-speak sees act " (c-get act)))]
(is (= (c-get alarm) :undefined))
(is (= 1 @+pulse+))
(is (= (c-get loc) :missing))
(is (= 1 @+pulse+))
(c-reset! act :leave)
(is (= 3 @+pulse+))
)))
;; -----------------------------------------------------------------
(deftest obs-setf-bad-caught
(cells-init)
(let [alarm (c-in :undefined :obs (obsdbg))
act (c-in nil :obs (obsdbg))
loc (c?+ [:obs (fn-obs (trx :loc-obs-runs!!!!)
(is (thrown-with-msg?
Exception
#"c-reset!> change"
(c-reset! act :leave)))
(when-not (= new :missing)
(c-reset-next! alarm (case new
:home :off
:away :on
(err format "unexpected loc %s" new)))))]
(case (c-get act)
:leave :away
:return :home
:missing))
alarm-speak (c?+ [:obs (fn-obs
(trx :alarm-speak (c-get act) :sees (c-get alarm) (c-get loc))
(is (= (c-get alarm) (case (c-get act)
:return :off
:leave :on
:undefined)))
(is (= +pulse+
(c-pulse act)
(c-pulse loc)
(c-pulse c))))]
(str "alarm-speak sees act " (c-get act)))]
(is (= (c-get alarm) :undefined))
(is (= 1 @+pulse+))
(is (= (c-get loc) :missing))
(is (= 1 @+pulse+))
))
;; --------------------------------------------------------
(deftest see-into-fn
(let [sia (c-in 0)
rsic (atom false)
sic (c? (reset! rsic true)
(+ 42 (c-get sia)))
fsia #(c-get sia)
sib (c? (or (+ 1 (fsia))
(c-get sic)))]
(is (= (c-get sib) 1))
(is (= (:useds @sib) #{sia}))
(is (not @rsic))
(c-reset! sia 1)
(is (= 2 (:value @sib)))
(is (= (c-get sib) 2))))
(deftest no-prop-no-obs
(let [sia (c-in 0)
obs (atom false)
sib (c?+ [:obs (fn-obs (reset! obs true))]
(if (even? (c-get sia))
42
10))
run (atom false)
sic (c? (reset! run true)
(/ (c-get sib) 2))]
(is (= (c-get sib) 42))
(is (= (c-get sic) 21))
(is @obs)
(is @run)
(dosync
(reset! obs false)
(reset! run false))
(c-reset! sia 2)
(is (= (c-get sib) 42))
(is (= (c-get sic) 21))
(is (not @obs))
(is (not @run))))
| 5,111 | Common Lisp | .cl | 120 | 23.25 | 96 | 0.342717 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6a8010ed7bdfbb565774467dea130a977a6deb0b33fa5849f5fb6de3fe54ee03 | 7,552 | [
-1
] |
7,553 | observer_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/observer_test.clj | (ns tiltontec.its-alive.observer-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.integrity :refer [with-integrity]]
[tiltontec.its-alive.evaluate :refer [c-get]]
[tiltontec.its-alive.observer :refer [defobserver fn-obs]]
[tiltontec.its-alive.cells :refer :all]
))
(set! *print-level* 3)
(deftest t-formula
(let [bingo (atom false)
c (c?+ [:slot :bingo
:obs (fn-obs
(reset! bingo true))]
(+ 40 2))]
(is (ia-type? c ::cty/cell))
(is (ia-type? c ::cty/c-formula))
(is (= (c-value-state c) :unbound))
(is (= #{} (c-callers c)))
(is (= #{} (c-useds c)))
(is (not (c-input? c)))
(is (not (c-valid? c)))
(is (nil? (c-model c)))
(is (= (c-get c) 42))
(is (= 42 @c)) ;; ie, optimized-away
(is @bingo)
))
(def bingo2 (atom false))
(defobserver :bingo2 [nil][]
;; (trx nil :bingoo2222222222!!!!! me new-value old-value c)
(reset! bingo2 true))
(deftest test-input
(let [c (c-in 42 :slot :bingo2)]
(is (ia-type? c ::cty/cell))
(is (= (c-value-state c) :valid))
(is (= #{} (c-callers c)))
(is (c-input? c))
(is (c-valid? c))
(is (nil? (c-model c)))
(is (= :bingo2 (c-slot c) (c-slot-name c)))
(is (= (c-get c) 42))
(is @bingo2)
))
(deftest t-custom-obs
(let [bobs (atom nil)
b (c-in 2 :slot :bb
:obs (fn-obs
(trx nil slot me new old)
(reset! bobs new)))
cobs (atom nil)
c (c?+ [:obs (fn-obs [slot me new old c]
(trx slot me new old)
(reset! cobs new))]
(* 10 (c-get b)))]
(dosync
(is (= (c-get b) 2))
(is (= @bobs 2))
(is (= (c-get c) 20))
;; (is (= @cobs 20))
;; (c-reset! b 3)
;; (is (= 3 @bobs))
;; (is (= 30 (c-get c)))
;; (is (= 30 @cobs))
)))
(def obj Object)
(defmacro get-obj []
`obj)
(defmulti speak (fn [one two] [(type one)(type two)]))
(derive ::dog ::animal)
(derive ::cat ::animal)
(defmethod speak [::dog Object] [_ _]
(println :woof))
(speak (atom nil :meta {:type ::dog}) 42)
(defmethod speak [::cat obj] [_ _]
(println :meow))
(speak (atom nil :meta {:type ::cat}) 42)
;; (def gotten-obj (obj/get-obj))
| 2,485 | Common Lisp | .cl | 78 | 24.871795 | 70 | 0.505444 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 797b0f9b122626a705239d1859841b1ab194d13cbf06fa6f893c5cb48d2da15d | 7,553 | [
-1
] |
7,554 | hello_world_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/hello_world_test.clj |
(ns tiltontec.its-alive.hello-world-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.model :refer :all :as md]
[tiltontec.its-alive.family :refer :all :as fm]
))
(deftest hw-01
(let [v ;;"visitor"
{:name "World"
:action (make-cell :value "knocks"
:input? true)}]
(println (c-get (:name v))
(c-get (:action v)))
(is (= (c-get (:name v)) "World"))
(is (= (c-get (:action v)) "knocks"))))
(deftest hw-02
(let [obs-action (atom nil)
v ;;"visitor"
{:name "World"
:action (c-in "knocks"
:slot :v-action
:obs ;; short for observer
(fn [slot me new old c]
(reset! obs-action new)
(println :observing slot new old)))}]
(is (= (c-get (:name v)) "World"))
(is (= (c-get (:action v)) "knocks"))
(is (= "knocks" @obs-action))))
(deftest hw-03
(let [action (atom nil)
obs-action (fn [slot me new old c]
(reset! action new)
(println :observing slot new old))
v {:name "World"
:action (c-in nil :slot :v-action
:obs obs-action)}]
(is (nil? (c-get (:action v))))
(is (nil? @action))
(c-reset! (:action v) "knock-knock")
(is (= "knock-knock" @action))
(is (= (c-get (:action v)) "knock-knock"))))
(defn gobs
[slot me new old c]
(println :gobs> slot new old))
(deftest hw-04
(let [r-action (c-in nil
:slot :r-action
:obs gobs)
r-loc (make-c-formula
:slot :r-loc
:obs gobs
:rule (fn [c]
(case (c-get r-action)
:leave :away
:return :at-home
:missing)))]
(c-awaken r-loc)
(is (= :missing (:value @r-loc)))
(println :---about-to-leave------------------)
(c-reset! r-action :leave)
(println :---left------------------)
(is (= :away (c-get r-loc)))))
(deftest hw-5
(println :--go------------------)
(let [obs-action (fn [slot me new old c]
(println slot new old))
v {:name "World"
:action (c-in nil :slot :v-action
:obs obs-action)}
r-action (c-in nil)
r-loc (c?+ [:obs (fn-obs (when new (trx :honey-im new)))]
(case (c-get r-action)
:leave :away
:return :home
:missing))
r-response (c?+ [:obs (fn-obs (trx :r-resp new))]
(when (= :home (c-get r-loc))
(when-let [act (c-get (:action v))]
(case act
:knock-knock "hello, world"))))]
(is (nil? (c-get r-response)))
(c-reset! (:action v) :knock-knock)
(c-reset! r-action :return)
(is (= :home (c-get r-loc)))))
(deftest hello-world
(println :--go------------------)
(let [obs-action (fn [slot me new old c]
(println slot new old))
v {:name "World"
:action (c-in nil
:slot :v-action
:ephemeral? true
:obs obs-action)}
r-action (c-in nil)
r-loc (c?+ [:obs (fn-obs (when new (trx :honey-im new)))]
(case (c-get r-action)
:leave :away
:return :home
:missing))
r-response (c?+ [:obs (fn-obs (trx :r-response new))
:ephemeral? true]
(when (= :home (c-get r-loc))
(when-let [act (c-get (:action v))]
(case act
:knock-knock "hello, world"))))]
(is (nil? (c-get r-response)))
(c-reset! (:action v) :knock-knock)
(c-reset! r-action :return)
(is (= :home (c-get r-loc)))
(c-reset! (:action v) :knock-knock)))
(deftest hello-world-2
(println :--go------------------)
(let [obs-action (fn [slot me new old c]
(when new (trx visitor-did new)))
v {:name "World"
:action (c-in nil
:slot :v-action
:ephemeral? true
:obs obs-action)}
r-action (c-in nil)
r-loc (c?+ [:obs (fn-obs (when new (trx :honey-im new)))]
(case (c-get r-action)
:leave :away
:return :home
:missing))
r-response (c?+ [:obs (fn-obs (when new
(trx :r-response new)))
:ephemeral? true
]
(when (= :home (c-get r-loc))
(when-let [act (c-get (:action v))]
(case act
:knock-knock "hello, world"))))
alarm (c?+ [:obs (fn-obs
(trx :telling-alarm-api new))]
(if (= :home (c-get r-loc)) :off :on))
alarm-do (c?+ [:obs (fn-obs
(case new
:call-police (trx :auto-dialing-911)
nil))]
(when (= :on (c-get alarm))
(when-let [action (c-get (:action v))]
(case action
:smashing-window :call-police
nil))))]
(c-awaken [alarm-do r-response r-loc (:action v)])
(is (= :missing (:value @r-loc)))
(c-reset! (:action v) :knock-knock)
(c-reset! (:action v) :smashing-window)
(c-reset! r-action :return)
(is (= :home (c-get r-loc)))
(c-reset! (:action v) :knock-knock)
))
| 6,319 | Common Lisp | .cl | 158 | 25.607595 | 66 | 0.424272 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6f081a8e3eb1de642fe6d6d7dc2ac0a1dcc9d7ef178722eac4ce57549b0f43c2 | 7,554 | [
-1
] |
7,555 | evaluate_test.clj | kennytilton_its-alive/test/tiltontec/its_alive/evaluate_test.clj | (ns tiltontec.its-alive.evaluate-test
(:require [clojure.test :refer :all]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.integrity :refer :all]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer [c-get]]
))
(set! *print-level* 3)
(deftest test-input
(let [c (c-in 42 :slot :bingo)]
(is (ia-type? c ::cty/cell))
(is (= (c-value-state c) :valid))
(is (= #{} (c-callers c)))
(is (c-input? c))
(is (c-valid? c))
(is (nil? (c-model c)))
(is (= :bingo (c-slot c) (c-slot-name c)))
(is (= (c-get c) 42))
))
(deftest t-formula
(let [c (c? (+ 40 2))]
(is (isa? ia-types ::cty/c-formula ::cty/cell))
(is (ia-type? c ::cty/cell))
(is (ia-type? c ::cty/c-formula))
(is (= (c-value-state c) :unbound))
(is (= #{} (c-callers c)))
(is (= #{} (c-useds c)))
(is (not (c-input? c)))
(is (not (c-valid? c)))
(is (nil? (c-model c)))
(trx nil :readddd (c-get c))
(is (= (c-get c) 42))
))
(deftest t-formula-2
(let [b (c-in 2)
cct (atom 0)
dct (atom 0)
c (c? (swap! cct inc)
(+ 40 (c-get b)))
d (c? (swap! dct inc)
(/ (c-get c)
(c-get b)))]
(is (= (c-get d) 21))
(is (= (c-get c) 42))
(is (= (c-get b) 2))
(is (= 1 @dct))
(is (= 1 @cct))
(is (= 0 (count (c-useds b))))
(is (= 2 (count (c-callers b))))
(is (= 1 (count (c-useds c))))
(is (= 1 (count (c-callers c))))
(is (= 2 (count (c-useds d))))
(is (= 0 (count (c-callers d))))
))
(def yowza (atom 0))
(defobserver :yowza [nil][]
(trx nil :yowza!!!!!!!!!!! slot new-value old-value)
(reset! yowza new-value))
(deftest t-in-reset
(reset! yowza 0)
(is (= @yowza 0))
(let [b (c-in 2 :slot :yowza)]
(is (= 2 (c-get b)))
(is (= 2 @yowza))
(c-reset! b 42)
(is (= 42 (c-get b)))
(is (= 42 @yowza))))
(deftest t-formula-22
(cells-init)
(let [b (c-in 2 :slot :bb)
cct (atom 0)
dct (atom 0)
c (c?+ [:slot :cc]
(swap! cct inc)
(+ 40 (c-get b)))
d (c?+ [:slot :dd]
(swap! dct inc)
(/ (c-get c)
(c-get b)))]
(dosync
(is (= (c-get d) 21))
(is (= (c-get c) 42))
(is (= (c-get b) 2))
(is (= 1 @dct))
(is (= 1 @cct)))
(c-reset! b 3)
(is (= (c-get d) 43/3))
(is (= (c-get c) 43))
(is (= (c-get b) 3))
(is (= 2 @dct))
(is (= 2 @cct))
))
;;; --- The Pentagram of Death: a hard use case for data integrity ------
#_
(alter-var-root #'*trx?* not)
(deftest pentagram-of-death
;;
;; Christened the Pentagram of Death by Phillip J Eby, this
;; is the use case that challenges an engine not to calculate
;; and observe transiently* inconsistent values when two different
;; dependency paths of one slot (here :ee) lead back to
;; the same slot (:aa).
;;
;; * "Transiently" because the state change propagation eventually**
;; gets :ee to the value consistent with the new state.
;; ** which is not
;; good enough because observers may have already fired and produced
;; side effects off the invalid state.
;;
;; The example is contrived but was contrived to replicate
;; a real dataflow failure that arose in my RoboCup simulation and
;; prompted Cells 3 and the concept of data integrity.
;;
;; For the telling story behind the useless slot names :aa, :bb et al
;; please see: http://smuglispweeny.blogspot.com/2008/07/aa-bb-cc-and-dd.html
;;
(cells-init)
(let [run (atom {})
obs (atom {})
rset (fn []
(swap! run empty)
(swap! obs empty))
logit (fn [log key]
(swap! run assoc key
(inc (key @run 0))))
logrun #(logit run %)
cr (fn [c]
(c-get c))
podobs (fn [slot me new old c]
(swap! obs assoc slot
(inc (slot @obs 0))))
aa (c-in 1 :slot :aa :obs podobs)
a7 (c-in 7 :slot :a7 :obs podobs)
a70 (c?+ [:slot :a70 :obs podobs]
(logrun :a70)
(* 10 (cr a7)))
bb (c?+ [:slot :bb :obs podobs]
(logrun :bb)
(cr aa))
cc (c?+ [:slot :cc :obs podobs]
(logrun :cc)
(* 10 (cr aa)))
dd (c?+ [:slot :dd :obs podobs]
(logrun :dd)
(if (even? (cr bb))
(* 10 (cr cc))
42))
ee (c?+ [:slot :ee :obs podobs]
(logrun :ee)
(+ (cr a70) (cr bb) (* 10000 (cr dd))))
verify-p-current (fn []
(is (= 2 (cr aa)))
(is (= 2 (cr bb)))
(is (= 20 (cr cc)))
(is (= 200 (cr dd)))
(is (= 2000072 (cr ee))))
]
;; next checks are just that the engine calculated well
;; and built a good dependency graph
;;
(is (= 1 (cr aa)))
(is (= 1 (cr bb)))
(is (= 10 (cr cc)))
(is (= 42 (cr dd)))
(is (= 420071 (cr ee)))
(is (= nil (c-useds aa)))
(is (= #{:bb :cc} (c-slots aa :callers)))
(is (= #{:aa} (c-slots bb :useds)))
(is (= #{:dd :ee} (c-slots bb :callers)))
(is (= #{:aa} (c-slots cc :useds)))
(is (= #{} (c-slots cc :callers)))
(is (= #{:bb} (c-slots dd :useds)))
(is (= #{:ee} (c-slots dd :callers)))
(is (= #{:a70 :bb :dd} (c-slots ee :useds)))
(is (= #{} (c-slots ee :callers)))
;; ;; now we come to data integrity: when change happens
;; ;; do all and only those cells affected recalculate
;; ;; and reobserve and do so exactly once.
;; ;;
(binding [*trx?* true]
(rset)
(trx nil :reset!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
(doseq [[k v] (seq @obs)]
(trx nil :obschk k v)
(is (and (keyword? k)
(= 0 v))))
(c-reset! aa (inc (cr aa)))
; check which rules ran
;
(= #{:bb :cc :dd :ee} ;; but not a7
(set (keys @run)))
;
; check those rules ran exactly once
;
(doseq [[k v] (seq @run)]
(trx nil :runchk k v)
(is (and (keyword? k)
(= 1 v))))
; check which observers ran
;
(= #{:aa :bb :cc :dd :ee}
(set (keys @obs)))
;
; check those observers ran exactly once
;
(doseq [[k v] (seq @obs)]
(trx nil :obschk k v)
(is (and (keyword? k)
(= 1 v))))
; check that this time dd branched to use cc as well as bb
;
(is (= #{:bb :cc} (c-slots dd :useds)))
(verify-p-current)
(c-reset! aa (inc (cr aa)))
; :aa hence :bb now odd so :dd goes back to 42
;
(is (= 42 (cr dd)))
;
; ...and check dependency on :cc got pruned
;
(is (= #{:bb} (c-slots dd :useds)))
)))
(deftest t-cell-unchanged-test
(cells-init)
(let [ob (atom 0)
b (c-in 2 :slot :bb
:obs (fn-obs (trx nil :obs-bb!! new old)
(swap! ob inc))
:unchanged-if (fn [n p]
(trx nil :ucif-sees n p)
(and (number? n)
(number? p)
(or (and (even? n)(even? p))
(and (odd? n)(odd? p))))))
cct (atom 0)
c (c?+ [:slot :cc]
(swap! cct inc)
(+ 40 (c-get b)))]
(is (= (c-get c) 42))
(is (= (c-get b) 2))
(is (= 1 @ob))
(is (= 1 @cct))
(c-reset! b 4)
(is (= (c-get c) 42))
(is (= (c-get b) 4))
(is (= 1 @ob))
(is (= 1 @cct))
(c-reset! b 5)
(is (= (c-get c) 45))
(is (= (c-get b) 5))
(is (= 2 @ob))
(is (= 2 @cct))))
(deftest opti-away
(let [aa (c? 42)]
(is (= 42 (c-get aa)))
(println :aa @aa)
(is (c-optimized-away? aa))
(is (= 42 @aa))))
| 8,356 | Common Lisp | .cl | 260 | 23.469231 | 79 | 0.456524 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ebf10d828cda151dc262f1e25b38f6cd793a4691d886059b9f2cab36d422e3d7 | 7,555 | [
-1
] |
7,557 | cells.clj | kennytilton_its-alive/src/tiltontec/its_alive/cells.clj | (ns tiltontec.its-alive.cells
(:require [tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.integrity :refer :all]))
(set! *print-level* 3)
(defn make-cell [& kvs]
(let [options (apply hash-map kvs)]
(ref (merge {:value unbound
:state :nascent
:pulse 0
:pulse-last-changed 0
:pulse-observed 0
:callers #{}
:lazy false ;; not a predicate (can hold, inter alia, :until-asked)
:ephemeral? false
:input? true
}
options)
:meta {:type ::tiltontec.its-alive.cell-types/cell})))
(defn make-c-formula [& kvs]
(let [options (apply hash-map kvs)
rule (:rule options)]
(assert rule)
(assert (fn? rule))
(ref (merge {:value unbound
:state :nascent ;; s/b :unbound?
:pulse 0
:pulse-last-changed 0
:pulse-observed 0
:callers #{}
:useds #{}
:lazy false
:ephemeral? false
:optimize true ;; this can also be :when-not-nil
:input? false ;; not redundant: can start with rule, continue as input
}
options)
:meta {:type ::tiltontec.its-alive.cell-types/c-formula})))
;;___________________ constructors _______________________________
;; I seem to have created a zillion of these, but I normally
;; use just c-in, c?, and c?n (which starts out as c? and becomes c-in).
;;
(defmacro c-fn-var [[c] & body]
`(fn [~c]
(let [~'me (c-model ~c)
~'cache (c-value ~c)]
~@body)))
(defmacro c-fn [& body]
`(c-fn-var (~'slot-c#) ~@body))
(defmacro c? [& body]
`(make-c-formula
:code '~body
:value unbound
:rule (c-fn ~@body)))
(defmacro c?+ [[& options] & body]
`(make-c-formula
~@options
:code '~body
:value unbound
:rule (c-fn ~@body)))
(defmacro c?+n [& body]
`(make-c-formula
:input? true
:code '~body
:value unbound
:rule (c-fn ~@body)))
(defmacro c?n [& body]
`(make-c-formula
:code '(without-c-dependency ~@body)
:input? true
:value unbound
:rule (c-fn (without-c-dependency ~@body))))
(defmacro c_?n [& body]
`(make-c-formula
:code '(without-c-dependency ~@body)
:input? true
:lazy :until-asked
:value unbound
:rule (c-fn (without-c-dependency ~@body))))
(defmacro c?n-dbg [& body]
`(make-c-formula
:code '(without-c-dependency ~@body)
:input? true
:debug true
:value unbound
:rule (c-fn (without-c-dependency ~@body))))
(defmacro c?n-until [args & body]
`(make-c-formula
:optimize :when-value-t
:code '~body
:input? true
:value unbound
:rule (c-fn ~@body)
~@args))
(defmacro c?once [& body]
`(make-c-formula
:code '(without-c-dependency ~@body)
:input? nil
:value unbound
:rule (c-fn (without-c-dependency ~@body))))
(defmacro c_1 [& body]
`(make-c-formula
:code '(without-c-dependency ~@body)
:input? nil
:lazy true
:value unbound
:rule (c-fn (without-c-dependency ~@body))))
(defmacro c?1 [& body]
`(c?once ~@body))
(defmacro c?dbg [& body]
`(make-c-formula
:code '~body
:value unbound
:debug true
:rule (c-fn ~@body)))
(defmacro c?_ [[& options] & body]
`(make-c-formula
~@options
:code '~body
:value unbound
:lazy true
:rule (c-fn ~@body)))
(defmacro c_? [[& options] & body]
"Lazy until asked, then eagerly propagating"
`(make-c-formula
~@options
:code '~body
:value unbound
:lazy :until-asked
:rule (c-fn ~@body)))
(defmacro c_?dbg [& body]
"Lazy until asked, then eagerly propagating"
`(make-c-formula
:code '~body
:value unbound
:lazy :until-asked
:rule (c-fn ~@body)
:debug true))
;; hhhhack add validation somewhere of lazy option
(defmacro c-formula [[& kvs] & body]
`(make-c-formula
:code '~body ;; debug aid
:value unbound
:rule (c-fn ~@body)
~@keys))
(defn c-in [value & option-kvs]
(apply make-cell
(list* :value value
:input? true
option-kvs)))
;; --- where change and animation begin -------
(defn c-reset! [c new-value]
"The moral equivalent of a Common Lisp SETF, and indeed
in the CL version of Cells SETF itself is the change API dunction."
(assert c)
(cond
*defer-changes*
(throw (Exception. "c-reset!> change to %s must be deferred by wrapping it in WITH-INTEGRITY"
(c-slot c)))
;-----------------------------------
(some #{(c-lazy c)} [:once-asked :always true])
(c-value-assume c new-value nil)
;-------------------------------------------
:else
(dosync
(with-integrity (:change (c-slot c))
(c-value-assume c new-value nil)))))
(defmacro c-reset-next! [f-c f-new-value]
"Observers should have side-effects only outside the
cell-mediated model, but it can be useful to have an observer
kick off further change to the model. To achieve this we
allow an observer to explicitly queue a c-reset! for
execution as soon as the current change is manifested."
`(cond
(not *within-integrity*)
(throw (Exception. "c-reset-next!> deferred change to %s not under WITH-INTEGRITY supervision."
(c-slot ~f-c)))
;---------------------------------------------
:else
(ufb-add :change
[:c-reset-next!
(fn [~'opcode ~'defer-info]
(let [c# ~f-c
new-value# ~f-new-value]
(cond
;;-----------------------------------
(some #{(c-lazy c#)} [:once-asked :always true])
(c-value-assume c# new-value# nil)
;;-------------------------------------------
:else
(dosync
(c-value-assume c# new-value# nil)))))])))
:cells-ok
| 6,255 | Common Lisp | .cl | 195 | 24.841026 | 100 | 0.541128 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 638f581684be5551a1574cbce18549294dda80b4664e946b32136a06b55ae6d9 | 7,557 | [
-1
] |
7,558 | family.clj | kennytilton_its-alive/src/tiltontec/its_alive/family.clj | (ns tiltontec.its-alive.family
(:require
[clojure.set :refer [difference]]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.family :refer :all :as fm]
))
(derive cty/ia-types ::family ::cty/model)
(def ^:dynamic *par* nil)
(defn fget= [seek poss]
(assert (any-ref? poss))
(cond
(fn? seek) (seek poss)
(keyword? seek)(do
;; (trx :fget=!!! seek @poss)
(= seek (:name @poss)))
:else (do ;; (trx :fget=-else! seek)
(= seek poss))))
(defn fget [what where & options]
;;(trx :fget-entry what where)
(when (and where what)
(let [options (merge {:me? false
, :inside? false
, :up? true
, :wocd? true ;; without-c-dependency
} (apply hash-map options))]
;;(trx :fget-beef what (md-name where) options)
(binding [*depender* (if (:wocd? options) nil *depender*)]
(or (and (:me? options)
(fget= what where)
where)
(and (:inside? options)
(if-let [kids (md-get where :kids)]
(do
;;(trx :fget-inside (:skip options)(doall (map md-name kids)))
(if-let [netkids (remove #{(:skip options)} kids)]
(do
;;(trx netkids!!! netkids)
(some #(fget what %
:me? true
:inside? true
:up? false) netkids))
(trx :no-net-kids)))
(trx nil :inside-no-kids @where)))
(and (:up? options)
(when-let [par (:par @where)]
;; (trx :fget-up (:name @par))
(fget what par
:up? true
:me? true
:skip where
:inside? true)))
(when (:must? options)
(err :fget-must-failed what where options)))))))
(defn fm! [what where]
(fget what where :me? false :inside? true :must? true :up? true))
(defmacro mdv! [what slot & [me]]
(let [me (or me 'me)]
`(md-get (fm! ~what ~me) ~slot)))
;; (macroexpand-1 '(mdv! :aa :aa3))
(defmacro the-kids [& tree]
`(binding [*par* ~'me]
(remove nil? (flatten (list ~@tree)))))
(defobserver :kids [::family][me newk oldk c]
(when-not (= oldk unbound)
(let [lostks (difference (set oldk)(set newk))]
(trx :lostks (flz lostks))
(when-not (empty? lostks)
(trx :bingo-lost! lostks)
(doseq [k lostks]
(trx :not-to-eing!!!!! k)
(not-to-be k))))))
#_
(dosync
(for [x #{(ref 1)}]
(not-to-be x)))
:family-ok
| 3,063 | Common Lisp | .cl | 80 | 26.1875 | 83 | 0.474234 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 019d8b8f99222c472608a0db80f57589afe2047b6fbd7faf5430b7719a3d56cd | 7,558 | [
-1
] |
7,559 | integrity.clj | kennytilton_its-alive/src/tiltontec/its_alive/integrity.clj | (ns tiltontec.its-alive.integrity
(:require [tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all]))
;; --- the pulse ------------------------------
(set! *print-level* 3)
(def ^:dynamic *one-pulse?* false)
(def ^:dynamic *dp-log* false)
(defn data-pulse-next
([] (data-pulse-next :anon))
([pulse-info]
(unless *one-pulse?*
(when *dp-log*
(trx "dp-next> " (inc @+pulse+) pulse-info))
(alter +pulse+ inc)))) ;; hhack try as commute
(defn c-current? [c]
(= (c-pulse c) @+pulse+))
(defn c-pulse-update [c key]
(when-not (c-optimized-away? c)
(assert (>= @+pulse+ (c-pulse c))
(format "Current DP %s not GE pulse %s of cell %s"
@+pulse+ (c-pulse c) @c))
(alter c assoc :pulse @+pulse+)))
;; --- ufb utils ----------------------------
(def +ufb-opcodes+ [:tell-dependents
:awaken
:client
:ephemeral-reset
:change])
(def unfin-biz
;; no nested finbiz allowed as of now, so just
;; build it and in use fill the queues, ufb -do them, and
;; ensure they are empty before continuing.
(into {} (for [i +ufb-opcodes+] [i (ref [])])))
(defn ufb-queue [opcode]
(or (opcode unfin-biz)
(err format "ufb-queue> opcode %s unknown" opcode)))
(defn ufb-queue-ensure [opcode]
"vestigial"
(or (ufb-queue opcode)
(err format
"ufb-queue-ensure now expects all queues to exist. %s does not. we have %s"
opcode (keys unfin-biz))))
(defn ufb-add [opcode continuation]
(fifo-add (ufb-queue-ensure opcode) continuation))
(defn ufb-assert-q-empty [opcode]
(if-let [uqp (fifo-peek (ufb-queue-ensure opcode))]
(do
(err format "ufb queue %s not empty, viz %s"
opcode uqp))
true))
;; --- the ufb and integrity beef ----------------------
;; proper ordering of state propagation
(def ^:dynamic *ufb-do-q* nil) ;; debug aid
(defn ufb-do
([opcode]
(ufb-do (ufb-queue opcode) opcode))
([q opcode]
;;(println :ufb-do opcode)
(when-let [[defer-info task] (fifo-pop q)]
(trx nil :ufb-do-yep defer-info task)
(task opcode defer-info)
(recur q opcode))))
(defn finish-business []
;; (println :fbiz!!!!!)
(un-stopped
(loop [tag :tell-dependents]
(case tag
:tell-dependents
(do (ufb-do :tell-dependents)
(ufb-do :awaken)
(recur
(if (fifo-peek (ufb-queue-ensure :tell-dependents))
:tell-dependents
:handle-clients)))
:handle-clients
(when-let [clientq (ufb-queue :client)]
(if-let [cqh @+client-q-handler+]
(cqh clientq)
(ufb-do clientq :client))
(recur
(if (fifo-peek (ufb-queue :client))
:handle-clients
:ephemeral-reset)))
:ephemeral-reset
(do (ufb-do :ephemeral-reset)
(recur :deferred-state-change))
:deferred-state-change
(when-let [[defer-info task-fn] (fifo-pop (ufb-queue :change))]
(data-pulse-next :def-state-chg)
(task-fn :change defer-info)
(recur :tell-dependents))))))
(defmacro with-integrity [[opcode info] & body]
`(call-with-integrity
~opcode
~info
(fn [~'opcode ~'defer-info]
~@body)))
(defmacro with-cc [id &body body]
`(with-integrity (:change ~id)
~@body))
(defmacro without-integrity [& body]
`(binding
[*within-integrity* false
*defer-changes* false
*call-stack* '()]
~@body))
(defn call-with-integrity [opcode defer-info action]
(when opcode
(assert (cl-find opcode +ufb-opcodes+)
(format "Invalid opcode for with-integrity: %s. Allowed values: %s"
opcode +ufb-opcodes+)))
(do ;; wtrx (0 1000 "cwi-begin" opcode *within-integrity*)
(un-stopped
(dosync
(cond
(c-stopped) (println :cwi-sees-stop!!!!!!!!!!!)
*within-integrity*
(if opcode
(prog1
:deferred-to-ufb-1
;; SETF is supposed to return the value being installed
;; in the place, but if the SETF is deferred we return
;; something that will help someone who tries to use
;; the setf'ed value figure out what is going on:
(ufb-add opcode [defer-info action]))
;; thus by not supplying an opcode one can get something
;; executed immediately, potentially breaking data integrity
;; but signifying by having coded the with-integrity macro
;; that one is aware of this.
;;
;; If you have read this comment.
;;
(action opcode defer-info))
:else (binding [*within-integrity* true
*defer-changes* false]
(when (or (zero? @+pulse+)
(= opcode :change))
(data-pulse-next :cwi))
(prog1
(action opcode defer-info)
(finish-business)
(ufb-assert-q-empty :tell-dependents)
(ufb-assert-q-empty :change))))))))
(defn ephemeral-reset [rc]
;; (trx :eph-reset?????? (:slot @rc)(:ephemeral? @rc))
(when (c-ephemeral? rc) ;; allow call on any cell, catch here
;
; as of Cells3 we defer resetting ephemerals because everything
; else gets deferred and we cannot /really/ reset it until
; within finish_business we are sure all callers have been recalculated
; and all observers completed (which happens with recalc).
;
;;(trx :ephh-reset!!! (:slot @rc))
(with-integrity (:ephemeral-reset rc)
(when-let [me (:me @rc)]
;; presumption next is that model cells live in
;; their own internal slot of model FNYI
(alter me assoc (:slot @rc) nil))
(alter rc assoc :value nil))))
:integrity-ok
| 6,002 | Common Lisp | .cl | 160 | 29.2 | 86 | 0.572888 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 66a30e675ef6c49e1b2f46feeeed7c519c0eae0296f799f6efc971a2094f65e9 | 7,559 | [
-1
] |
7,560 | cell_types.clj | kennytilton_its-alive/src/tiltontec/its_alive/cell_types.clj | (ns tiltontec.its-alive.cell-types
(:require [tiltontec.its-alive.utility :refer :all]))
;; --- the Cells beef -----------------------
(def +pulse+ (ref 0))
(defn cells-init []
(dosync
(ref-set +pulse+ 0)))
(def ^:dynamic *causation* '())
(def ^:dynamic *call-stack* nil)
(def ^:dynamic *depender*
"*depender* let's us differentiate between the call stack and
and dependency. The problem with overloading *call-stack* with both roles
is that we miss cyclic reentrance when we use without-c-dependency in a
rule to get once behavior or just when fm-traversing to find someone"
nil)
(def ^:dynamic *defer-changes* false)
(def +client-q-handler+ (atom nil))
(defonce unbound (gensym "unbound-cell-value"))
(defonce uncurrent (gensym "uncurrent-formulaic-value"))
(def ^:dynamic *not-to-be* false)
(def ^:dynamic *unfinished-business* nil)
(def ^:dynamic *within-integrity* false)
;; --- debug stuff -----------------------------
(def ^:dynamic *finbiz-id* 0)
(def ^:dynamic *c-prop-depth* 0)
(def +c-debug+ (atom false))
(def ^:dynamic +stop+ (atom false)) ;; emergency brake
;; --- procedure division ----------------------
(defn cells-reset
([] (cells-reset {}))
([options]
(reset! +c-debug+ (:debug options false))
(reset! @+pulse+ 0)
(reset! +client-q-handler+ (:client-queue-handler options))))
(defmacro without-c-dependency [& body]
`(binding [*depender* nil]
~@body))
(defn .cause []
(first *causation*))
;; --- 19000 ----------------------------------
(defn c-stopper [why]
(reset! +stop+ why)) ;; in webserver, make sure each thread binds this freshly
(def +c-stopper+ (atom c-stopper))
(defn c-stop
([] (c-stop true))
([why]
(@+c-stopper+ why)))
(defn c-stopped []
@+stop+)
(defmacro un-stopped [& body]
`(when-not @+stop+
~@body))
(defn ustack$ [tag] ;; debug aid
(str tag "ustack> "(vec (map (fn [c] (:slot @c)) *call-stack*))))
(defn c-assert
([assertion] (when-not assertion
(err "c-assert anon failed")))
([assertion fmt$ & fmt-args]
(unless +stop+
(unless assertion
(apply #'err format (str "c-assert> " fmt$)
fmt-args)))))
(defn c-break [& args]
(unless +stop+
(err (apply 'str args))))
(defn c-warn [& args]
(unless +stop+
(format "WARNING!!!!!!!!! %s"
(apply 'str args))))
;; ---------------------------------------------------------
(defonce ia-types (-> (make-hierarchy)
(derive ::model ::object)
(derive ::cell ::object)
(derive ::c-formula ::cell)))
(defn ia-type? [it typ]
(isa? ia-types (type it) typ))
(defn c-formula? [c]
(ia-type? c ::c-formula))
(defn c-ref? [x]
(ia-type? x ::cell))
(def-rmap-slots c-
me slot state input? rule pulse pulse-last-changed pulse-observed
useds users callers optimize ephemeral?
lazy synaptic?)
(defn c-value [c]
(assert (any-ref? c))
(cond
(and (c-ref? c)
(map? @c)) (:value @c)
:else @c))
(defn c-optimized-away? [c]
(cond
(c-ref? c) (or (not (map? @c))
(= :optimized-away (:state @c)))
:else true))
(defn c-model [rc]
(:me @rc))
(defn c-slot-name [rc]
(:slot @rc))
(defn c-value-state [rc]
(let [v (c-value rc)]
(cond
(= v unbound) :unbound
(= v uncurrent) :uncurrent
:else :valid)))
(defn c-unbound? [rc]
(= :unbound (c-value-state rc)))
(defn c-valid? [rc]
(= :valid (c-value-state rc)))
;; --- dependency maintenance --------------------------------
(defn caller-ensure [used new-caller]
(alter used assoc :callers (conj (c-callers used) new-caller)))
(defn caller-drop [used caller]
(alter used assoc :callers (disj (c-callers used) caller)))
(defn unlink-from-callers [c]
(for [caller (c-callers c)]
(caller-drop c caller))
(rmap-setf [:callers c] nil))
;; debug aids --------------
(defn c-slots [c k]
(assert (c-ref? c))
(set (map c-slot (k @c))))
;; --- defmodel rizing ---------------------
(defn md-ref? [x]
;;(trx :md-ref?-sees x)
(and (instance? clojure.lang.Ref x)
;; hhack (ia-type? x ::model)
))
;; --- mdead? ---
(defmulti mdead? (fn [me]
(assert (or (nil? me)
(md-ref? me)))
[(type (when me @me))]))
(defmethod mdead? :default [me]
false)
;;---
(set! *print-level* 3) ;; cells are recursive data for now
(defn md-slot-owning? [class-name slot-name]
;; hhack
false)
:cell-types-ok
| 4,561 | Common Lisp | .cl | 141 | 27.77305 | 80 | 0.572967 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 14f62f9d87077ebe24fe00688167c3029e5364fa13560b7a0f77d6c1e886ef18 | 7,560 | [
-1
] |
7,561 | observer.clj | kennytilton_its-alive/src/tiltontec/its_alive/observer.clj | (ns tiltontec.its-alive.observer
(:use [tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all]))
(defmulti observe (fn [slot-name me new-val old-val c]
[slot-name
(type (when (md-ref? me) me))
(type new-val)
(type old-val)]))
#_
(obs-reset)
(defn obs-reset []
(remove-all-methods observe)
(defmethod observe :default [slot me new-val old-val c]
;; (println :obs-fall-thru slot (type @me) new-val old-val c)
))
(defmethod observe :default [slot me new-val old-val c]
#_(println :obs-fall-thru slot
(cond
(md-ref? me)(type me)
:else me)
new-val old-val c))
(defmacro defobserver [slot types params & body]
(assert (keyword? slot) "defobserver> slot should be a keyword.")
(let [ftypes (concat types (take-last (- 3 (count types))
'(::tiltontec.its-alive.cell-types/model Object Object)))
fparams (concat params
(take-last (- 4 (count params))
'(me new-value old-value c)))]
`(defmethod tiltontec.its-alive.observer/observe [~slot ~@ftypes][~'slot ~@fparams]
~@body)))
(defmacro fn-obs
"Shortcut definer for cell-specific observers.
body can be multiple sexprs with access to
call parameters: slot, me, new, old, and c."
[& body]
`(fn [~'slot ~'me ~'new ~'old ~'c]
~@body))
(defn c-observe
([c why]
(c-observe c unbound why))
([c prior-value why]
;; (trx :cobs-3 (c-slot c) why)
(assert (c-ref? c))
(rmap-setf [:pulse-observed c] @+pulse+)
;;(trx :c-obs-pulse! (c-slot c) why @+pulse+ (:obs @c))
;;(trx :c-obs-value! why (c-slot c) (c-model c) (c-value c) prior-value c)
((or (:obs @c) observe)
(c-slot c)(c-model c)(c-value c) prior-value c)))
:observer-ok
| 1,922 | Common Lisp | .cl | 49 | 31.408163 | 97 | 0.577814 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | e8160ccf89aac6cebf1e470a9b0b372a62b45b72ec8066d6ed4ac928d6e86e29 | 7,561 | [
-1
] |
7,562 | evaluate.clj | kennytilton_its-alive/src/tiltontec/its_alive/evaluate.clj | (ns tiltontec.its-alive.evaluate
(:require
[clojure.set :refer [difference]]
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.integrity :refer :all]))
(set! *print-level* 3)
(defn record-dependency [used]
(when-not (c-optimized-away? used)
(assert *depender*)
(trx nil :reco-dep!!! :used (c-slot used) :caller (c-slot *depender*))
(rmap-setf [:useds *depender*]
(conj (c-useds *depender*) used))
(caller-ensure used *depender*)))
(declare calculate-and-set )
(defn ensure-value-is-current
"The key to data integrity: recursively check the known dependency
graph to decide if we are current, and if not kick off recalculation
and propagation."
[c debug-id ensurer]
(cond
; --------------------------------------------------
*not-to-be* ; we got kicked off during not-to-be processing
; just return what we have if valid, else nil
(cond
(c-unbound? c)
(err "evic> unbound slot %s of model %s"
(c-slot c)(c-model c))
(c-valid? c) ;; probably accomplishes nothing
(c-value c))
;; --- easy way out: our pulse is current ---------------
(c-current? c)
(c-value c)
;; --- also easy with an optimize edge case lost to history -------
(and (c-input? c)
(c-valid? c) ;; a c?n (ruled-then-input) cell will not be valid at first
(not (and (c-formula? c)
(= (c-optimize c) :when-value-t)
(nil? (c-value c)))))
(c-value c)
;; --- above we had valid values so did not care. now... -------
(when-let [md (c-model c)]
(mdead? (c-model c)))
(err format "evic> model %s of cell %s is dead" (c-model c) c)
;; --- no more early exits -------------------
(or (not (c-valid? c))
(loop [[used & urest] (seq (c-useds c))]
(when used
(ensure-value-is-current used :nested c)
;; now see if it actually changed
(or (> (c-pulse-last-changed used)(c-pulse c))
(recur urest)))))
(do ;; we seem to need update, but...
;; (trx nil :seem-to-need)
(unless (c-current? c)
(trx nil :not-current-so-calc)
;; happens if dependent changed and its observer read/updated me
(calculate-and-set c :evic ensurer))
(c-value c))
;; we were behind the pulse but not affected by the changes that moved the pulse
;; record that we are current to avoid future checking:
:else (do ;(trx nil :just-pulse)
(c-pulse-update c :valid-uninfluenced)
(c-value c))))
(defn c-get
"The API for determing the value associated with a Cell.
Ensures value is current, records any dependent, and
notices if a standalone cell has never been observed."
[c]
(cond
(c-ref? c) (prog1
(with-integrity ()
(let [prior-value (c-value c)]
(prog1
(ensure-value-is-current c :c-read nil)
;; this is new here, intended to awaken standalone cells JIT
;; /do/ might be better inside evic, or test here
;; to see if c-model is nil? (trying latter...)
(when (and (nil? (c-model c))
(= (c-state c) :nascent)
(> @+pulse+ (c-pulse-observed c)))
(rmap-setf [:state c] :awake)
(c-observe c prior-value :c-get)
(ephemeral-reset c)))))
(when *depender*
(record-dependency c)))
(any-ref? c) @c
:else c))
(declare calculate-and-link
c-value-assume)
(defn calculate-and-set
"Calculate, link, record, and propagate."
[c dbgid dbgdata]
(let [raw-value (calculate-and-link c)]
;;(trx :c-set (c-slot c) raw-value)
(when-not (c-optimized-away? c)
(assert (map? @c) "calc-n-set")
;; this check for optimized-away? arose because a rule using without-c-dependency
;; can be re-entered unnoticed since that clears *call-stack*. If re-entered, a subsequent
;; re-exit will be of an optimized away cell, which will have been assumed
;; as part of the opti-away processing.
(c-value-assume c raw-value nil))))
(declare unlink-from-used)
(defn calculate-and-link
"The name is accurate: we do no more than invoke the
rule of a formula and return its value, but along the
way the links between dependencies and dependents get
determined anew."
[c]
(binding [*call-stack* (cons c *call-stack*)
*depender* c
*defer-changes* true]
(unlink-from-used c :pre-rule-clear)
(assert (c-rule c) (format "No rule in %s type %s" (:slot c)(type @c)))
((c-rule c) c)))
;;; --- awakening ------------------------------------
(defmulti c-awaken #(type (if (any-ref? %1) %1 %1)))
(defmethod c-awaken :default [c]
;;(trx :awk-fallthru-entry (type c)(seq? c)(coll? c)(vector? c))
(cond
(coll? c) (doall (for [ce c]
(c-awaken ce)))
:else
(println :c-awaken-fall-thru (if (any-ref? c)
[:ref-of (type c) @c]
[:unref c (type c)]))))
(defmethod c-awaken ::cty/cell [c]
(assert (c-input? c))
;
; nothing to calculate, but every cellular slot should be output on birth
;
;; (trx :awk-input (c-slot c)@+pulse+ (c-pulse-observed c))
(dosync
(when (> @+pulse+ (c-pulse-observed c)) ;; safeguard against double-call
(when-let [me (c-me c)]
(rmap-setf [(c-slot c) me] (c-value c)))
(c-observe c :cell-awaken)
(ephemeral-reset c))))
(defmethod c-awaken ::cty/c-formula [c]
(dosync
;; hhack -- bundle this up into reusable with evic
;; (trx :c-formula-awk (c-slot c)(c-current? c))
(binding [*depender* nil]
(when-not (c-current? c)
(calculate-and-set c :fn-c-awaken nil)))))
;; ------------------------------------------------------------
(declare c-absorb-value
optimize-away?!
propagate
c-value-changed?)
(defn md-slot-value-store [me slot value]
(assert me)
(assert (any-ref? me))
;(trx :mdsv-store slot (flz value))
(rmap-setf [slot me] value))
(defn c-value-assume
"The Cell assumes a new value at awakening, on c-reset!, or
after formula recalculation.
We record the new value, set the Cell state to :awake, make
its pulse current, check to see if a formula cell can be
optimized away, and then propagate to any dependent formula
cells."
[c new-value propagation-code]
(assert (c-ref? c))
(do ;; wtrx (0 1000 :cv-ass (:slot @c) new-value)
(prog1 new-value ;; sans doubt
(without-c-dependency
(let [prior-value (c-value c)
prior-state (c-value-state c)]
;; --- cell maintenance ---
;; hhhack: new for 4/19/2016: even if no news at
;; least honor the reset!
;;
(rmap-setf [:value c] new-value)
(rmap-setf [:state c] :awake)
#_(trx :new-vlue-installed (c-slot c)
new-value
(:value c))
;;
;; --- model maintenance ---
(when (and (c-model c)
(not (c-synaptic? c) ))
(md-slot-value-store (c-model c) (c-slot-name c) new-value))
(c-pulse-update c :slotv-assume)
(when (or (= propagation-code :propagate) ;; forcing
(not (some #{prior-state} [:valid :uncurrent]))
(c-value-changed? c new-value prior-value))
;;
;; --- something happened ---
;;
;; we may be overridden by a :no-propagate below, but anyway
;; we now can look to see if we can be optimized away
(let [callers (c-callers c)] ;; get a copy before we might optimize away
(when-let [optimize (and (c-formula? c)
(c-optimize c))]
(trx nil :wtf optimize)
(case optimize
:when-value-t (when (c-value c)
(trx nil :when-value-t (c-slot c))
(unlink-from-used c :when-value-t))
true (optimize-away?! c prior-value)))
;; --- data flow propagation -----------
(when-not (or (= propagation-code :no-propagate)
(c-optimized-away? c))
(assert (map? @c))
(propagate c prior-value callers)))))))))
;; --- unlinking ----------------------------------------------
(defn unlink-from-used [c why]
"Tell dependencies they need not notify us when they change,
then clear our record of them."
(for [used (c-useds c)]
(do
(rmap-setf [:callers used] (disj (c-callers used) c))))
(rmap-setf [:useds c] #{}))
(defn md-cell-flush [c]
(assert (c-ref? c))
(when-let [me (c-model c)]
(rmap-setf [:cells-flushed me]
(conj (:cells-flushed me)
[(c-slot c)(c-pulse-observed c)]))))
;; --- optimize away ------------------------------------------
;; optimizing away cells who turn out not to depend on anyone
;; saves a lot of work at runtime.
(defn optimize-away?!
"Optimizes away cells who turn out not to depend on anyone,
saving a lot of work at runtime. A caller/user will not bother
establishing a link, and when we get to models c-get! will
find a non-cell in a slot and Just Use It."
[c prior-value]
;;(trx :opt?! (c-formula? c))
(when (and (c-formula? c)
(empty? (c-useds c))
(c-optimize c)
(not (c-optimized-away? c)) ;; c-streams (FNYI) may come this way repeatedly even if optimized away
(c-valid? c) ;; /// when would this not be the case? and who cares?
(not (c-synaptic? c)) ;; no slot to cache invariant result, so they have to stay around)
(not (c-input? c)) ;; yes, dependent cells can be inputp
)
;;(trx :opti-away!!!! @c)
(rmap-setf [:state c] :optimized-away) ;; leaving this for now, but we toss
; the cell below. hhack
(c-observe c prior-value :opti-away)
(when-let [me (c-model c)]
(rmap-meta-setf [:cz me] (dissoc (:cz @me) (c-slot c)))
(md-cell-flush c))
;; let callers know they need not check us for currency again
(doseq [caller (seq (c-callers c))]
(alter caller assoc :useds (remove #{c} (c-useds caller)))
(caller-drop c caller)
;;; (trc "nested opti" c caller)
;;(optimize-away?! caller) ;; rare but it happens when rule says (or .cache ...)
(ensure-value-is-current caller :opti-used c)) ;; this will get round to optimizing
; them if necessary, and if not they do need
; to have one last notification if this was
; a rare mid-life optimization
;;(trx :opti-nailing-c-map!!!!!!! (c-slot c))
(ref-set c (c-value c))
))
;; --- c-quiesce -----------
(defn c-quiesce [c]
(unlink-from-callers c)
(unlink-from-used c :quiesce)
(ref-set c :dead-c))
;; --- not-to-be --
(defmulti not-to-be (fn [me]
(assert (md-ref? me))
[(type (when me @me))]))
(defmethod not-to-be :default [me]
(trx :n2be-deflt me)
(trx :n2be-deflt me (type (when me @me)))
(doseq [c (vals (:cz (meta me)))]
(c-quiesce c))
(ref-set me nil)
(rmap-meta-setf [:state me] :dead))
;----------------- change detection ---------------------------------
(defmulti unchanged-test
"Cells does not propagate when nothing changes. By default, the
test is =, but cells can inject a different test, and when we get
to models it will be possible for a slot to have associated
with it a different test."
(fn [me slot]
[(when me (type @me)) slot]))
(defmethod unchanged-test :default [self slotname]
;;(trx :std-unchanged slotname)
=)
(defn c-value-changed? [c new-value old-value]
;(trx :unchanged? (:slot @c) new-value old-value)
(not ((or (:unchanged-if @c)
(unchanged-test (c-model c) (c-slot c)))
new-value old-value)))
;;--------------- change propagation ----------------------------
(def ^:dynamic *custom-propagater* nil)
(declare propagate-to-callers
md-slot-cell-flushed)
(defn propagate
"A cell:
- notifies its callers of its change;
- calls any observer; and
- if ephemeral, silently reverts to nil."
;; /do/ support other values besides nil as the "resting" value
[c prior-value callers]
(trx nil :propagate (:slot @c))
(cond
*one-pulse?* (when *custom-propagater*
(*custom-propagater* c prior-value))
;; ----------------------------------
:else
(do
(rmap-setf [:pulse-last-changed c] @+pulse+)
(binding [*depender* nil
*call-stack* nil
*c-prop-depth* (inc *c-prop-depth*)
*defer-changes* true]
;; --- manifest new value as needed ---
;;
;; 20061030 Trying not.to.be first because doomed instances may be interested in callers
;; who will decide to propagate. If a family instance kids slot is changing, a doomed kid
;; will be out of the kids but not yet quiesced. If the propagation to this rule asks the kid
;; to look at its siblings (say a view instance being deleted from a stack who looks to the psib
;; pb to decide its own pt), the doomed kid will still have a parent but not be in its kids slot
;; when it goes looking for a sibling relative to its position.
(when (and prior-value
(c-model c)
(md-slot-owning? (type (c-model c)) (c-slot-name c)))
(when-let [ownees (difference (set-ify prior-value) (set-ify (c-value c)))]
(doseq [ownee ownees]
(not-to-be ownee))))
(propagate-to-callers c callers)
(trx nil :obs-chkpulse!!!!!!!! @+pulse+ (c-pulse-observed c))
(when (or (> @+pulse+ (c-pulse-observed c))
(some #{(c-lazy c)}
[:once-asked :always true])) ;; messy: these can get setfed/propagated twice in one pulse+
(c-observe c prior-value :propagate))
;;
;; with propagation done, ephemerals can be reset. we also do this in c-awaken, so
;; let the fn decide if C really is ephemeral. Note that it might be possible to leave
;; this out and use the pulse to identify obsolete ephemerals and clear them
;; when read. That would avoid ever making again bug I had in which I had the reset
;; inside slot-value-observe,
;; thinking that that always followed propagation to callers. It would also make
;; debugging easier in that I could find the last ephemeral value in the inspector.
;; would this be bad for persistent CLOS, in which a DB would think there was still a link
;; between two records until the value actually got cleared?
;;
(ephemeral-reset c)))))
(defn propagate-to-callers [c callers]
;;
;; We must defer propagation to callers because of an edge case in which:
;; - X tells A to recalculate
;; - A asks B for its current value
;; - B must recalculate because it too uses X
;; - if B propagates to its callers after recalculating instead of deferring it
;; - B might tell H to reclaculate, where H decides this time to use A
;; - but A is in the midst of recalculating, and cannot complete until B returns.
;; but B is busy eagerly propagating. "This time" is important because it means
;; there is no way one can reliably be sure H will not ask for A
;;
(when-not (empty? callers)
(let [causation (cons c *causation*)] ;; closed over below
(with-integrity (:tell-dependents c)
(if (mdead? (c-model c))
(do (trx "WHOAA!!!! dead by time :tell-deps dispatched; bailing" c))
(binding [*causation* causation]
(doseq [caller (seq callers)]
(cond
(or ;; lotsa reasons NOT to proceed
(= (c-state caller) :quiesced)
(c-current? caller) ;; happens if I changed when caller used me in current pulse+
(some #{(c-lazy caller)} [true :always :once-asked])
(and (not (some #{c} (c-useds caller))) ; hard to follow, but it is trying to say
(not (c-optimized-away? c)))) ; "go ahead and notify caller one more time
; even if I have been optimized away cuz they need to know."
; Note this is why callers must be supplied, having been copied
; before the optimization step.
(trx nil :not-propping (c-slot c) :to (c-slot caller))
:else
(calculate-and-set caller :propagate c)))))))))
:evaluate-ok
| 17,670 | Common Lisp | .cl | 379 | 36.641161 | 113 | 0.557463 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ba2e81d2a9a0c3bd1e7819c0480f78a06c8aaae3ea3f3fa5ebfad21b7653f357 | 7,562 | [
-1
] |
7,563 | model.clj | kennytilton_its-alive/src/tiltontec/its_alive/model.clj | (ns tiltontec.its-alive.model
(:require
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.integrity :refer :all]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.cells :refer :all]
[tiltontec.its-alive.model-base :refer :all]
[tiltontec.its-alive.family :refer :all]
))
;;; --- accessors ----
(defn md-reset! [me slot new-value]
;;(trx :md-reset!!!!!!! slot (md-name me) new-value)
(if-let [c (md-cell me slot)]
(c-reset! c new-value)
(do
(err format "change to slot %s not mediated by cell" slot)
(rmap-setf [slot me] new-value))))
(defn make [& iargs]
(cond
(odd? (count iargs)) (apply make :type iargs)
:else
(dosync
(let [me (ref (merge {:par *par*}
(->> iargs
(partition 2)
(filter (fn [[slot v]]
(not (= :type slot))))
(map (fn [[k v]]
(vector k (if (c-ref? v)
unbound
v))))
(into {})))
:meta (merge {:state :nascent}
(->> iargs
(partition 2)
(filter (fn [[slot v]]
(= :type slot)))
(map vec)
(into {}))))]
(assert (meta me))
(rmap-meta-setf
[:cz me]
(->> iargs
(partition 2)
(filter (fn [[slot v]]
(md-install-cell me slot v)))
(map vec)
(into {})))
(with-integrity (:awaken me)
(md-awaken me))
me))))
(def kwt "[email protected]")
(apply str (reduce (fn [[& as][& xs]]
(vec (map str as xs)))
(partition 3 kwt)))
| 2,174 | Common Lisp | .cl | 57 | 22.719298 | 64 | 0.411848 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6a92864d36b63ddec5fd4769a891efbd9c9938a3d01ff3ba728fe6d30ad475c0 | 7,563 | [
-1
] |
7,564 | model_base.clj | kennytilton_its-alive/src/tiltontec/its_alive/model_base.clj | (ns tiltontec.its-alive.model-base
(:require
[tiltontec.its-alive.utility :refer :all]
[tiltontec.its-alive.cell-types :refer :all :as cty]
[tiltontec.its-alive.evaluate :refer :all]
[tiltontec.its-alive.integrity :refer :all]
[tiltontec.its-alive.observer :refer :all]
[tiltontec.its-alive.cells :refer :all]
))
(def-rmap-slots md-
name)
(def-rmap-meta-slots md-
state cz)
(defn md-cell [me slot]
(slot (:cz (meta me))))
;;; --- md initialization ---
(declare md-awaken)
(defn md-install-cell [me slot c]
;; note that c (a misnomer) might not be a Cell
(cond
(c-ref? c) (do
(alter c assoc
:slot slot
:me me)
(rmap-setf [slot me]
(when (c-input? c)
(c-value c)))
true)
:else (do
(rmap-setf [slot me] c)
false)))
(defn md-awaken
"(1) do initial evaluation of all ruled slots
(2) call observers of all slots"
[me]
(c-assert (= :nascent (md-state me)))
(rmap-meta-setf [:state me] :awakening)
;;(trx :md-awk @me)
(doall
(for [slot (keys @me)]
(let [c (slot (md-cz me))]
(cond
c (do ;(trx :slot-c slot c)
(c-awaken c))
:else (do ;(trx :noslot slot (slot @me) me)
(observe slot me (slot @me) unbound nil))))))
(rmap-meta-setf [:state me] :awake)
me)
(defn md-get [me slot]
;;(trx :md-get!!!!!!! slot (md-name me))
(if-let [c (md-cell me slot)]
(c-get c)
(slot @me)))
| 1,598 | Common Lisp | .cl | 53 | 22.830189 | 64 | 0.543137 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 962e6381384bba25e9edf56aa7e417fbcba6ad7594057f514791d25a2331b33c | 7,564 | [
-1
] |
7,565 | utility.clj | kennytilton_its-alive/src/tiltontec/its_alive/utility.clj | (ns tiltontec.its-alive.utility
(:require [clojure.string :as $]))
(set! *print-level* 2) ;; lose this if we lose recursive data structures
(defmacro prog1 [& body]
`(let [result# ~(first body)]
~@(rest body)
result#))
(defmacro b-when [var form & body]
`(when-let [~var ~form]
~@body))
(defn cl-find [sought coll]
(some #{sought} coll))
(defmacro unless [form & body]
`(when-not ~form
~@body))
(defn type-of [x] (type x))
(defn set-ify [x]
(cond
(nil? x) #{}
(sequential? x) (set x)
:else #{x}))
;; --- refs with maps conveniences -------------------
(defmacro def-rmap-slots [reader-prefix & slots]
`(do
~@(map (fn [slot#]
`(defn ~(symbol (str (or reader-prefix "")
slot#))
[~'ref]
(~(keyword slot#) @~'ref))) slots)))
(defn any-ref? [x]
(instance? clojure.lang.Ref x))
(defn rmap-setf [[slot ref] new-value]
(assert (any-ref? ref))
(assert (map? @ref))
(alter ref assoc slot new-value)
new-value)
(defmacro def-rmap-meta-slots [reader-prefix & slots]
`(do
~@(map (fn [slot#]
`(defn ~(symbol (str (or reader-prefix "")
slot#))
[~'ref]
(~(keyword slot#) (meta ~'ref)))) slots)))
(defn rmap-meta-setf [[slot ref] new-value]
(assert (meta ref))
(alter-meta! ref assoc slot new-value)
new-value)
;; --- error handling -----------------
(do
(defmulti err (fn [a1 & args] (fn? a1)))
(defmethod err true [fn & mas]
(err (apply fn mas)))
(defmethod err :default [& bits]
(throw (Exception. ($/join " " (cons "jz/err>" bits))))))
;; ---- debug print statement hacks ---------------------
(def ^:dynamic *trx?* true)
#_
(alter-var-root #'*trx?* not)
(def ^:dynamic *trc-ensure* nil)
(def ^:dynamic *trx-path-id* nil)
(def ^:dynamic *trxdepth* 0)
(def last-trc (atom 0)) ;; s/b universal time
(defn call-trc$ [s bits]
(str s ": " ($/join ", " bits)))
;; (call-trc$ nil (list :himom-shouldnot-appear 1 2 3))
;; (call-trc$ "cool" (list :himom-shouldnot-appear 1 2 3))
(defn call-trc [s & os]
;; (break) ;; uncomment to escape loop
(when *trx?*
(when s
(let [path (apply str (repeat *trxdepth* "."))]
(println path (call-trc$ s os))))))
(defn flz [x]
(if (isa? (type x) clojure.lang.LazySeq)
(vec (doall x))
x))
#_
(flz (map even? [1 2 3]))
(defmacro trx [label & vals]
`(call-trc ~(when (not (nil? label))
(str label))
~@vals))
(defmacro wtrx [[lo hi & trxargs] & body]
`(binding [*trxdepth* (inc *trxdepth*)]
(cond
(<= ~lo *trxdepth* ~hi)
(trx ~@trxargs)
(> *trxdepth* ~hi)
(throw (Exception. (str
(format "wtrx exceeded max(%d): " ~hi)
(call-trc$ '~(first trxargs)
(list ~@(rest trxargs)))))))
~@body))
#_
(binding [*trxdepth* 5]
(wtrx (0 100 "cool" 1 2 3)
(println :body)))
(defn wtrx-test [n]
(wtrx (0 10 "test" n)
(when (> n 0)
(wtrx-test (dec n)))))
;; --- deftest support ---------------------
;; These next two are lame because they just
;; look at slots (ignoring models). Use only
;; in tests looking at one model or at least
;; slot names do not duplicate.
;;
(defn slot-users [me slot]
(set (map :slotq
(map deref
(:callers @(slot @me) #{})))))
(defn slot-useds [me slot]
(set (map :slot
(map deref
(:useds @(slot @me) #{})))))
;;; --- FIFO Queue -----------------------------
(defn make-fifo-queue []
(ref []))
(defn fifo-data [q] @q)
(defn fifo-clear [q]
(alter q empty))
(defn fifo-empty? [q]
(empty? @q))
(defn fifo-peek [q]
(first @q))
(defn fifo-add [q new]
(alter q conj new))
(defn fifo-pop [q]
(when-not (fifo-empty? q)
(prog1
(first @q)
(alter q subvec 1))))
;;; --- learning curve exercises
;;
(comment
(loop [[slot v & r] '(:a 0 :b 1 :c 9)
acc (transient {})]
(if (nil? slot)
(persistent! acc)
(recur r (assoc! acc
slot
(cond
(typep v :jz)
(merge {:slot slot} v)
:else v)))))
(into (hash-map)
(map (fn [[k v]] (vector k (inc v)))
(partition 2 '(:a 0 :b 1 :c 9))))
(reduce (fn [m [k v]]
(assoc m k (inc v)))
(hash-map)
(partition 2 '(:a 0 :b 1 :c 9))))
:utility-ok
| 4,578 | Common Lisp | .cl | 153 | 23.705882 | 72 | 0.514501 | kennytilton/its-alive | 21 | 1 | 0 | EPL-1.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 441c14d5d1e2cbcb2da3f2d32e88120d120d1cfd1455a48916ab3db0b86af5fb | 7,565 | [
-1
] |
7,658 | vsett_display_dual_vesc.lisp | aka13-404_VSETT-LISP/vsett_display_dual_vesc.lisp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; User settings ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;"Profile" settings: max-speed (km,h), motor-current
; Kmh get rounded stupidly to m/s
(define profile_1 (list 10 20))
(define profile_2 (list 15 30))
(define profile_3 (list 22 40))
(define profile_S2 (list 100 30))
(define profile_S3 (list 100 90))
;;;Set the id of the other VESC (no, not doing that automatically, for your safety)
(define can_slave_id_list (list 61))
;;;P06 and P07 set in display (important for speed calc)
(define p06 10)
(define p07 30) ;Should be same as magnets in vesc
;;; Combo for two additional modes triggered by light on
(define gear-key [1 2 3 2 3 2 3])
;Stuff below this line is for nerds, don't touch it if you don't know what you are doing
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;UART configuration on COM-Port
;;;Refer to https://github.com/aka13-404/IO-Hawk-Legacy-Info for protocol details
(uart-start 1200)
(define display-packet (bufcreate 16)); No idea why it does not work with 15
(define packet-length 15)
(define esc-packet (bufcreate 15))
(bufset-u8 esc-packet 0 0x36) ;Esc header
;todo - explain in the main docks where the key comes from, explain how it works
(define encoding-key-array [
0x5e 0x23 0x5c 0x21 0x2a 0x2f 0x28 0x2d 0x26 0x2b 0x24 0x29 0x52 0x57 0x50 0x55
0x4e 0x53 0x4c 0x51 0x5a 0x5f 0x58 0x5d 0x56 0x5b 0x54 0x59 0x02 0x07 0x00 0x05
0x3e 0x03 0x3c 0x01 0x0a 0x0f 0x08 0x0d 0x06 0x0b 0x04 0x09 0x32 0x37 0x30 0x35
0x2e 0x33 0x2c 0x31 0x3a 0x3f 0x38 0x3d 0x36 0x3b 0x34 0x39 0x62 0x67 0x60 0x65
0x1e 0x63 0x1c 0x61 0x6a 0x6f 0x68 0x6d 0x66 0x6b 0x64 0x69 0x12 0x17 0x10 0x15
0x0e 0x13 0x0c 0x11 0x1a 0x1f 0x18 0x1d 0x16 0x1b 0x14 0x19 0x42 0x47 0x40 0x45
0x7e 0x43 0x7c 0x41 0x4a 0x4f 0x48 0x4d 0x46 0x4b 0x44 0x49 0x72 0x77 0x70 0x75
0x6e 0x73 0x6c 0x71 0x7a 0x7f 0x78 0x7d 0x76 0x7b 0x74 0x79 0x22 0x27 0x20 0x25])
(define encoded-bytes [ 3 4 5 7 8 9 10 11 12 13 ])
;;; Convert human-readable speed into m/s speed
(setix profile_1 0 (/ (ix profile_1 0) 3.6))
(setix profile_2 0 (/ (ix profile_2 0) 3.6))
(setix profile_3 0 (/ (ix profile_3 0) 3.6))
(setix profile_S2 0 (/ (ix profile_S2 0) 3.6))
(setix profile_S3 0 (/ (ix profile_S3 0) 3.6))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Debug stuff ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define debug 0)
(defun print-bytes (x)
(progn
(var debug-print-packet "")
(looprange each 0 packet-length
(setvar 'debug-print-packet (str-merge debug-print-packet (str-from-n (bufget-u8 x each)) " "))
)
(print debug-print-packet)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Converting data from vesc for the display functions ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Speed display
(defun speed-calc () (* (* p07 (/ (get-speed) (* p06 3.1415 0.0254))) 1.52069))
; get m/s, divide by wheel circumference in m to get rotation/s, multiply by magnets
;(we are going backwards to something a la erpm), multiply by unknown factor (please help me understand why that factor exists, check excel, run experiments)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Converting data from display for the vesc functions ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Gets gear number and applies changes
;Checks if gears have changed; If they changed, change some modes.
(define last-gear 0)
(define last-light 0)
(define profile_S_switch 0)
(defun gear-calc (gear light)
(progn
(if (!= last-gear gear)
(progn
(cond
((= gear 5) ; Gear 1
(progn ;Here is a list of commands, which get run when profile change to 1
(gear-history 1)
(set-param 'max-speed (ix profile_1 0) can_slave_id_list)
(set-param 'l-current-max (ix profile_1 1) can_slave_id_list)
(setvar 'profile_S_switch 0)
)
)
((= gear 10) ; Gear 2
(if (eq profile_S_switch 0) ;Here is a list of commands, which get run when profile change to 2 + S2
(progn
(gear-history 2)
(set-param 'max-speed (ix profile_2 0) can_slave_id_list)
(set-param 'l-current-max (ix profile_2 1) can_slave_id_list)
)
(progn
(set-param 'max-speed (ix profile_S2 0) can_slave_id_list)
(set-param 'l-current-max (ix profile_S2 1) can_slave_id_list)
)
)
)
((= gear 15) ; Gear 3
(if (eq profile_S_switch 0) ;Here is a list of commands, which get run when profile change to 3 + S3
(progn
(gear-history 3)
(set-param 'max-speed (ix profile_3 0) can_slave_id_list)
(set-param 'l-current-max (ix profile_3 1) can_slave_id_list)
)
(progn
(set-param 'max-speed (ix profile_S3 0) can_slave_id_list)
(set-param 'l-current-max (ix profile_S3 1) can_slave_id_list)
)
)
)
)
(setvar 'last-gear gear)
)
)
(if (!= last-light light)
(progn
(if (and (eq light 1) (eq gear-key gear-history-array))
(progn
(setvar 'profile_S_switch 1)
(setvar 'last-gear 228)
(bufset-u8 esc-packet 4 32)
)
)
(setvar 'last-light light)
)
)
;For debug purposes - prints gear history
;(print gear-history-array)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Service functions ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Checksum function
(defun crc-calc (x)
(progn
(var crc 0) ; checksum resets each loop
(looprange each 0 (- packet-length 1)
(setvar 'crc (bitwise-xor crc (bufget-u8 x each)))
)
)
)
;;;Function to set config parameter to local and all specified vescs
(defun set-param (param value can_slave_id_list)
(progn
(conf-set param value)
(loopforeach i can_slave_id_list
(can-cmd i (str-merge "(conf-set " "'" (sym2str param) " " (str-from-n value) ")"))
)
)
)
;;; Function to store last gears selected
(define gear-history-array [1 1 1 1 1 1 1])
(defun gear-history (gear)
(progn ;Shifts values left, writes last value to the rightmost place
(loopforeach each (range 6) (bufset-u8 gear-history-array each (bufget-u8 gear-history-array (+ each 1))))
(bufset-u8 gear-history-array 6 gear)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Reader and Writer ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Writer - writes to display
(defun writer ()
(progn
(var counter 0)
(var enc-key 0)
(loopwhile t
(progn
;Counter in Byte 1
(setvar 'counter (bufget-u8 esc-packet 1))
(if (< counter 255) (bufset-u8 esc-packet 1 (+ counter 1)) (bufset-u8 esc-packet 1 0))
;Speed Byte 7 & 8
(bufset-u16 esc-packet 7 (speed-calc))
;Encoding the
;Step 1 - get encoding key from table
(if (< (bufget-u8 esc-packet 1) 128)
(setvar 'enc-key (bufget-u8 encoding-key-array (bufget-u8 esc-packet 1)))
(setvar 'enc-key (bufget-u8 encoding-key-array (- (bufget-u8 esc-packet 1) 128)))
)
;Step 2 - apply encoding key to every encoded byte, remove everything over 256 (propably should be written more human-friendly)
(looprange each 0 (buflen encoded-bytes) (bufset-u8 esc-packet (bufget-u8 encoded-bytes each) (mod (+ (bufget-u8 esc-packet (bufget-u8 encoded-bytes each)) enc-key) 256)))
;Calculate checksum
(bufset-u8 esc-packet 14 (crc-calc esc-packet))
(uart-write esc-packet)
(sleep 0.05);No idea why it is necessary; Breaks
;Send packet to display
(bufclear esc-packet 0 2)
(yield 150000)
;;;Writer end
)
)
)
)
;;;Reader
(defun reader ()
(loopwhile t
(progn
(uart-read-bytes display-packet 1 0) ;Read first byte
(if (eq (bufget-u8 display-packet 0) 1) ;If first byte 1, read one more
(progn
(uart-read-bytes display-packet 1 1) ;Read second byte
(if (eq (bufget-u8 display-packet 1) 3) ;If second byte 3, read remaining
(progn
(uart-read-bytes display-packet 13 2)
(if (eq (bufget-u8 display-packet 14) (crc-calc display-packet))
;If the remaining has coherent checksum, do stuff:
(progn
;Read gears and lamp status for the gear switcher
(gear-calc (bufget-u8 display-packet 4) (if (= 8 (bitwise-and 8 (bufget-u8 display-packet 9))) 1 0))
(yield 75000)
)
)
)
)
)
)
)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Starts reader and writer
(spawn 150 reader)
(spawn 150 writer) | 11,138 | Common Lisp | .lisp | 228 | 37.350877 | 187 | 0.467367 | aka13-404/VSETT-LISP | 15 | 5 | 2 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 5d097232ff2c3e4951a6647328c62190b885f49e4114bf0ede4e907501fc40bc | 7,658 | [
-1
] |
7,660 | Installation.md | aka13-404_VSETT-LISP/Installation.md | # Installation/Configuration
I assume, that if you install VESC, you are fairly comfortable with making decisions and weighting your options. I am not going to make them for you.
**I recommend reading the whole thing before starting, so that you won't do unnecessary work.**
## 1. Display pinout
### Display
This is the pinout of the display on the VSETT10. The QS-S4 _should_ be the same, but I did not check.
The names come from how they are labeled on stock controllers. Here is what they mean:
1. RXD - Receiver part of the UART. The display expects data from the ESC here.
2. GND
3. TXD - Sender part of the UART. The display sends data to the ESC here.
4. SD - Throttle signal. This varies between about 0.9 and 4 volts.
5. VCC - "Ignite" - when the display is enabled and unlocked, battery voltage gets sent back here.
6. VBAT - Power for the display
### ESC
This is the connector which will go to your ESC. **Don't forget, the pins will be mirrored, and RX connects to TX!** Also, don't trust your cable colors. There is no uniform color standard, so cable colors can vary. Check with a multimeter, before connecting to your ESC.
1. TXD - Sender part of the UART. The ESC will send data to the display here.
2. GND
3. RXD - Receiver part of the UART. The display expects data from the ESC here.
4. SD - Throttle signal. Don't forget - **DON'T CONNECT DIRECTLY - THE STM32 HANDLES UP TO 3.3V, not up to 4V**
5. VCC/Ignite - can be connected to enable/disable your ESC
6. VBAT - Should be connected to VBAT, to supply power to display.
## 2. Connecting
### 1. BOM
Materials that you will need will vary depending on what you are connecting to the display.
Some stuff will be needed, no matter the details:
1. 6-pin female Julet connector, >800mm length. I have resorted to using 2 extensions cables - 1 for the stem, another cut in half to connect to the VESC.
2. Connectors/wires/soldering stuff to somehow connect to your VESC. I have connectors for crimping, and build connections as I need. A premade harness which you cut and solder to is also absolutely ok. Sometimes soldering will be inevitable, depending on connector sizes - some wires may be too thick/thin for direct connections.
3. Most likely some resistors. Read further, to know what you will really need.
### 2. Connect UART, GND, VBAT - Easy
This is as easy as it sounds - power to the display, UART RX/TX and GND can be connected directly on all VESCs I have seen on the market so far.
### 3. Connecting throttle - Medium
If you read the pinout part, you know, that the throttle signal sent by the display is higher, than the microcontroller on the VESC can handle. So now you have two options:
#### 1. Option 1 - direct connection
If you, like me, don't have any additional hardware attached, you will need a [divider](https://ohmslawcalculator.com/voltage-divider-calculator), which will reduce the voltage range, that comes from the throttle.
If you know how it is done, you know how it is done.
If you don't, here is my suggestion how to tackle it (ignore resistor colors, I took the first I found for the demonstation):
1. You should propably keep the lower arm below 10k, to not mess with impedance on the input.
2. Any combo that gives you the desired 3.3v max from 4v is absolutely ok - you could use 10k on the lower arm, and 2,2k on the upper arm - you could also use 3.3k/1k. Just make sure you are below 3.3V, and above 3V, to not loose too much resolution.
1. Take your breadboard, solder two resistors in, connect the THR from the Julet connector and GND and ADC1 connection from your VESC. If you want, you can also connect the GND for the display on the same breadboard, if you don't want to use it from a connector.
2. Clean the flux off the board, cut off (I use a sidecutter for that) unneeded bits, cross the wires to go along the pcb so that you can use it with a ziptie as to relief stress from the solder joint.
3. Add heatshrink and a ziptie to fix the wires to the PCB.
You can do the same without a breadboard, but I advise you against that.
The breadboard has following advantages:
1. You do not rely on the resistors mechanical strength
2. Your soldering is not under constant mechanical stress, and so vibrations don't matter
3. You can easily mount it anywhere in any form
4. You can use smd resistors, if you have them
#### 2. Option 2 - "adc board"
I don't use them, but I know they exist - boards with extension ports, which allow to connect 5v throttle/brake sensors, and have a built-in divider, which can be adjusted. It works in exactly the same way, as the method described above. I have no idea on the other ramifications, how and what it does, research it yourself, if you need it.
### 4. Connecting "ignite" - Easy to hard
The stock controller on the VSETT handles the turning on/off in an industry-standard fashion - the DCDC stepwown, which powers the logic of the esc, gets enabled or disabled, while the power stage on the ESC remains connected to the energy source. While the implementation varies slightly between manufacturers, it remains the same for ninebot, xiaomi and all other scooters.
Sadly, so far Benjamin has not been focusing on e-scooters, so his ideas on how VESC should be turned on/off have been slightly different, and the chinese manufacturers all handle it slightly different from one to the other, ranging from very good to very bad implementations. You will be dealing with one of those implementations:
#### 1. Easiest to connect, best implementation of power on/off - ESC with an "ignite" port
While in general, the VESC in the picture (in my opinion) is shit, the presence of an "ignite" port makes it a breeze to connect to. It operates on the same assumption, as the stock ESC and other common escs on the market - apply VBAT to ignite, to turn on the logic stage, remove it to disable the logic stage. Just wire everything up with the divider to take care of the throttle, and you are good:
#### 2. Not too bad to connect, no implementation of power on/off - ESC without any enable/"ignite" ports
Some VESCs, nowadays "older" ones, like the 75100 alu, or the 75100 brick (both are shit as well, in my opinion), don't have any way to enable/disable them natively. This is not as bad as it may seem. They still are structured the same, where there is a dcdc stepdown powering the logic part, which can be disabled. All the recent chinese designs _I have seen_ use the **SCT SCT2A23ASTER** stepdown. It has an EN leg, which controls its behaviour:
- Float or connect to VIN to enable the converter.
- Pull below 1.23V to disable the converter.
What that means for us, is that we want the EN leg pulled to ground at all times, except for when the display is on/unlocked. The minimum needed setup would be a single resistor to GND, but this causes issues with huge drain current, so the most elegant solution is a divider. This time though, you **will have to calculate it on your own**.
The EN leg has to be pulled down with a fairly small resistor, 10k or less. This means you have to calculate the upper arm of the resistor according to your battery voltage, so that the voltage on the EN leg remains over 1.2 (preferably a bit more, so that it does not turn off on a dip). It sounds complicated, but I assure you, it is not.
Assuming that you stick with the 10k for the lower arm:
**Attention** - if you connect multiple a23a in parallel this way (you have a dual drive escoot), 10k may be too much. If your escs don't reliably turn off, when the screen turns off, you may want to go with a lower resistor, for example a 5k resistor, which I do for my dual-drives. Adjust the calculations accordingly.
1. Check when your BMS cuts off your battery. This is the voltage, until which you propably want to keep the VESC enabled either way. The cutoff is propably around 3v or similar per cell. For a 14s battery, that would mean, that the lowest voltage you can get, would be 14s * 3v = 42v. Let's say you have a cutoff at 3.3v per cell, and a 20s battery. That would in turn mean that the lowest you go is 20s * 3.3v = 66v. You can calculate that easily for any cutoff and voltage you wish for.
2. Now that we know, that the lowest voltage we will get from the screen to the VCC will be around 42v in our first example, we go back to the [divider calculator](https://ohmslawcalculator.com/voltage-divider-calculator), and enter the values accordingly: _R2_ is 10kOhm, our desired _output voltage_ is above 1.23v - let's take a safety margin, and go with 3v, just to be sure it won't dip lower on a battery sag, our _source voltage_ is 42v. The result is 130kOhm.
3. Most likely, you won't have a resistor of the precise value that you calculated, and that's quite alright. We have a very large range to work with, as long as we stay above 2v for our EN leg, on the lowest battery voltage you are comfortable with. Play around in the divider calculator with resistors that you have, and aim for the "above 1.2v" target.
4. (Bonus) You may ask at this point, "why do I even need a divider, if the EN leg can handle Vbat? Can't I just attach VCC to it, and a resistor to ground? The answer is yes and no. The problem arises with the power flowing from vcc through the resistor, directly to ground. If you have read until here, you propably are comfortable with basic math, so consider this - we only keep the 10kOhm resistor to GND, and apply VCC directly.
According to Ohms Law, to get the current, we divide our voltage (on our 14s example battery, fully charged that would be 14s * 4.2v = 58.8v) by our resistance (10kOhm resistor), and get the current. 58.8v / 10 000 Ohm=0.00588A, or 5.88mA. Power, as you know, is calculated P = I * V, or in our case, 58.8v * 0.00588A = 0,345744W(!). That's quite a lot of heat to dissipate and power consumed for simply having your ESC turned on.
You can't really go higher than 10k, because it limits the current too much, so that the EN pin is never fully pulled to the ground. That's why we build the divider. Since the divider from the VCC perspective is two resistors in series, and almost nothing flows to the EN pin, we can calculate the total current over R1 + R2. Let's say we picked 100k for R1. 58.8v / (100 000Ohm + 10 000Ohm) = 0.000534A, or 0.534mA. That's only 0.03W to waste and dissipate, which is way nicer.
The end result should look similar to this:
And the general schematic similar to this:
#### 3. Not-so-fun to connect, floating + VESC reference implementation for power on/off - ESC with conn_sw
Recent vescs related to 84100 and 84200 have started adopting the reference design from Benjamin, with a couple of cargocult-like moments. While the gesture is appreciated - out of the box turning off and all that, for most escoot purposes is nightmarish to work with at best. I have only looked at the 84100 so far, so I can not judge, if the pcb layout will be the same for other versions. To connect this one properly, you have to understand, how this "keep enable/shutdown" works.
This is what the implementation on the 84100 and 84200 of makerbase looks like:
If you are interested in the placement on the pcb, I have retraced it [here](img/pcb_layout.png)
It looks way scarier than it is. We still have the a23a with the EN leg. If the switch is flipped to the right, the EN leg is connected to the close-enough-to-reference-implementation from Benjamin, which is useless for us. It works in reverse, by being constantly on, and using short-term button presses to GND to turn off, and turn on on wheel movement. No idea what it was made for, propably those longboards?
But don't fret! **If the switch is to the left, you guessed it, the EN is floating as usual!** That means you can simply follow the process outlined before, with calculating a divider. The only difference - **you solder not to the leg directly, but to the "always on" part of the switch** After you have calculated everything, simply solder a wire to the floating part of the switch, and flip it to the left. The mode of operations can now be switched at will when needed between the reference implementation of Benjamin, and our desired "ignite" configuration.
Here is the principal schematic, on what it should look like:
Sadly, this time, there is no nice space to place the resistors. For my projects I usually run 2 escs, so I decided to simply place both dividers (one for the throttle, another for the enable) on a separate pcb I connect the screen to.
Ignore the size, I simply have a "standard" breadboard holder for my experiments. You really only need a very small piece.
### Step 5: Check your pinouts
At this point you should be ready to roll. Make sure that all your pins are going to where you intend them to go to. Make sure that your vbat is not shortcircuiting somewhere you don't want it to shortcircuit. Make sure the resistors you used for the dividers are really what they said on the box. Make sure your cabling is a-ok.
### Step 6: Power on from a controlled power source
Ideally you should have a bench power supply, where you can limit the current. If not, put your BMS protection to absurdly low values, something under 1A, and power on. If magic smoke has not exited your escs, then everything should be good, and you can proceed with the next steps.
### Step 7: Power on via the display
Stuff working should be:
1. The display turns on
2. The display turns on your vesc, if you have ignition connected to vcc of display
3. You can see throttle input in the ADC. Don't forget to enable RT App in the configurator
### Step 8: Upload the script to your vesc
1. **Make sure you are using 6.05 firmware**
2. Open the configurator
3. Make sure magnets and wheel diameter are set the same/correctly for all VESCs. Otherwise speed limits will not be applied properly.
4. Click on VESC Dev tools
5. Click on the LISP tab
6. Copy the contents of [the script](vsett_display_dual_vesc.lisp) to the window
7. Adjust the parameters to your desired values - see parameter description below
8. Click on upload (don't forget, you should be uploading to the VESC the display is connected to)
9. Error 10 should disappear, everything should be working
The following parameters are available right now:
1. The profiles
First number is max-speed in km/h, second number is motor current.
These numbers are applied to all vescs listed in the slaves list
```lisp
(define profile_1 (list 10 20))
(define profile_2 (list 15 30))
(define profile_3 (list 22 40))
(define profile_S2 (list 100 30))
(define profile_S3 (list 100 90))
```
2. The list of slave-escs
Here you should write the number you see in the lower left corner in the configurator. If you have more than 2 motors, you can add those here.
```lisp
(define can_slave_id_list (list 61))
```
3. P-Values
The display uses some magic formula for speed calculation.
The script needs the P-Values of tire diameter and magnets set in the display.
```lisp
(define p06 10)
(define p07 30)
```
4. Hidden modes switch
This is the sequence of gears, which needs to be entered before enabling lights, to unlock hidden modes. A couple of limitations:
1. It has to be 7 items long
2. You can not have same numbers following eachother, obviously
It works like this:
1. You switch gears, in the order you entered in the script. Don't do it too fast - it does not register otherwise. About 2 switches per second are okay.
2. You enable the lights, by holding the + button.
3. The display blinks the (!) to let you know, that the sequence was accepted.
4. Your gears 2 and 3 now use the parameters from profile_S2 and profile_S3 respectively.
5. Switching to gear 1 returns you to the usual profile 1-3.
### Step 9: Make sure everything works as expected
Basically you should be set to go, but make sure that the gears work as you expect them to, and change the max erpm on every esc.
If you think something is missing from the guide, let me know.
| 16,694 | Common Lisp | .l | 147 | 111.340136 | 561 | 0.769801 | aka13-404/VSETT-LISP | 15 | 5 | 2 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | d9e489e9067c883eea8ccf182ec5dcea5b0fb9681c833a063373b79a8a9fba6c | 7,660 | [
-1
] |
7,662 | Divider_principal.drawio | aka13-404_VSETT-LISP/img/Divider_principal.drawio | <mxfile host="Electron" modified="2023-06-23T10:02:26.651Z" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/21.5.0 Chrome/112.0.5615.204 Electron/24.5.1 Safari/537.36" etag="_Idx0VkKTmcjDXqgx0Ey" version="21.5.0" type="device">
<diagram name="Page-1" id="6ks8-aGRb-3t2DkxkZou">
<mxGraphModel dx="-388" dy="334" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="9K6-PW_eZZa0o3FRrNUu-3" value="3.3 kΩ" style="pointerEvents=1;verticalLabelPosition=bottom;shadow=0;dashed=0;align=center;html=1;verticalAlign=top;shape=mxgraph.electrical.resistors.resistor_2;rotation=0;" vertex="1" parent="1">
<mxGeometry x="1130" y="570" width="75" height="15" as="geometry" />
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-4" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;entryPerimeter=0;endArrow=none;endFill=0;" edge="1" parent="1" source="9K6-PW_eZZa0o3FRrNUu-3" target="9K6-PW_eZZa0o3FRrNUu-2">
<mxGeometry relative="1" as="geometry" />
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-2" value="1 kΩ" style="pointerEvents=1;verticalLabelPosition=bottom;shadow=0;dashed=0;align=center;html=1;verticalAlign=top;shape=mxgraph.electrical.resistors.resistor_2;rotation=0;" vertex="1" parent="1">
<mxGeometry x="1210" y="570" width="75" height="15" as="geometry" />
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-5" value="" style="endArrow=none;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;strokeWidth=3;" edge="1" parent="1" source="9K6-PW_eZZa0o3FRrNUu-3">
<mxGeometry width="50" height="50" relative="1" as="geometry">
<mxPoint x="1200" y="600" as="sourcePoint" />
<mxPoint x="1130" y="500" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-6" value="GND" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="9K6-PW_eZZa0o3FRrNUu-5">
<mxGeometry x="0.2826" y="-2" relative="1" as="geometry">
<mxPoint as="offset" />
</mxGeometry>
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-16" value="" style="endArrow=none;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;strokeWidth=3;strokeColor=#007FFF;" edge="1" parent="1">
<mxGeometry width="50" height="50" relative="1" as="geometry">
<mxPoint x="1210" y="578" as="sourcePoint" />
<mxPoint x="1210" y="500" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-17" value="ADC 1" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="9K6-PW_eZZa0o3FRrNUu-16">
<mxGeometry x="0.2826" y="-2" relative="1" as="geometry">
<mxPoint as="offset" />
</mxGeometry>
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-18" value="" style="endArrow=none;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;strokeWidth=3;strokeColor=#007FFF;" edge="1" parent="1">
<mxGeometry width="50" height="50" relative="1" as="geometry">
<mxPoint x="1285" y="578" as="sourcePoint" />
<mxPoint x="1285" y="500" as="targetPoint" />
</mxGeometry>
</mxCell>
<mxCell id="9K6-PW_eZZa0o3FRrNUu-19" value="THR SIGNAL" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" vertex="1" connectable="0" parent="9K6-PW_eZZa0o3FRrNUu-18">
<mxGeometry x="0.2826" y="-2" relative="1" as="geometry">
<mxPoint as="offset" />
</mxGeometry>
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>
| 4,119 | Common Lisp | .l | 52 | 69.673077 | 349 | 0.652399 | aka13-404/VSETT-LISP | 15 | 5 | 2 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 30d9fe1905dfbad4e5ca8557fd126126d257f80f7c29cfd9f889215a2235b552 | 7,662 | [
-1
] |
7,663 | DisplayPinout.drawio | aka13-404_VSETT-LISP/img/DisplayPinout.drawio | <mxfile host="Electron" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/24.7.5 Chrome/126.0.6478.183 Electron/31.3.0 Safari/537.36" version="24.7.5">
<diagram name="Page-1" id="MBNOfd6OtYcJmXM9TG5Z">
<mxGraphModel dx="-224" dy="830" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="tR3VETBykpzzzQw2HGaD-22" value="Display/Gas" style="swimlane;whiteSpace=wrap;html=1;" vertex="1" parent="1">
<mxGeometry x="1720" y="90" width="520" height="250" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-23" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-22">
<mxGeometry x="30" y="54" width="146" height="146" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-24" value="" style="group" vertex="1" connectable="0" parent="1">
<mxGeometry x="1940" y="162" width="281.25" height="165" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-25" value="" style="group;perimeterSpacing=0;strokeWidth=1;movable=1;resizable=1;rotatable=1;deletable=1;editable=1;locked=0;connectable=1;" vertex="1" connectable="0" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="75" width="130" height="130" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-26" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;fillColor=none;strokeWidth=2;fontColor=#733a00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry width="127.5" height="127.5" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-27" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="60" y="10" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-28" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="20" y="40" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-29" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="100" y="40" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-30" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="20" y="80" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-31" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="100" y="80" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-32" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="60" y="58.75" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-33" value="" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.half_circle;rotation=-180;strokeWidth=2;fillColor=none;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="51.25" y="107.5" width="25" height="20" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-34" value="<font style="font-size: 11px;">3 - TXD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#CCCC00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="25" y="30" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-35" value="<span style="font-size: 11px;"><font color="#007fff">6 - VBAT</font></span>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#CCCC00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="27.5" y="90" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-36" value="6-Pin-Julet male" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-170" y="132" width="440" height="30" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-37" value="<font style="font-size: 11px;">1 - RXD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#FF0000;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="205" y="77.5" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-38" value="<font style="font-size: 11px;">2 - GND</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="205" y="40" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-39" value="<font color="#00ad00" style="font-size: 11px;">5 - VCC</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-1.25" y="77.5" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-40" value="<font color="#787878" style="font-size: 11px;">4 - SD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-1.25" y="40" width="75" height="10" as="geometry" />
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>
| 192,008 | Common Lisp | .l | 67 | 2,856.820896 | 185,608 | 0.949844 | aka13-404/VSETT-LISP | 15 | 5 | 2 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c63de6377c76d05ab353255c6741914363281c4c54964d3d2608c4d3edff513e | 7,663 | [
-1
] |
7,664 | .$DisplayPinout.drawio.bkp | aka13-404_VSETT-LISP/img/.$DisplayPinout.drawio.bkp | <mxfile host="Electron" agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/24.7.5 Chrome/126.0.6478.183 Electron/31.3.0 Safari/537.36" version="24.7.5">
<diagram name="Page-1" id="MBNOfd6OtYcJmXM9TG5Z">
<mxGraphModel dx="-224" dy="830" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
<root>
<mxCell id="0" />
<mxCell id="1" parent="0" />
<mxCell id="tR3VETBykpzzzQw2HGaD-22" value="Display/Gas" style="swimlane;whiteSpace=wrap;html=1;" vertex="1" parent="1">
<mxGeometry x="1720" y="90" width="520" height="250" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-23" value="" style="shape=image;verticalLabelPosition=bottom;labelBackgroundColor=default;verticalAlign=top;aspect=fixed;imageAspect=0;image=data:image/png,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;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-22">
<mxGeometry x="30" y="54" width="146" height="146" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-24" value="" style="group" vertex="1" connectable="0" parent="1">
<mxGeometry x="1940" y="162" width="281.25" height="165" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-25" value="" style="group;perimeterSpacing=0;strokeWidth=1;movable=1;resizable=1;rotatable=1;deletable=1;editable=1;locked=0;connectable=1;" vertex="1" connectable="0" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="75" width="130" height="130" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-26" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;fillColor=none;strokeWidth=2;fontColor=#733a00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry width="127.5" height="127.5" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-27" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="60" y="10" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-28" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="20" y="40" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-29" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="100" y="40" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-30" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="20" y="80" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-31" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="100" y="80" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-32" value="" style="ellipse;whiteSpace=wrap;html=1;aspect=fixed;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="60" y="58.75" width="10" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-33" value="" style="verticalLabelPosition=bottom;verticalAlign=top;html=1;shape=mxgraph.basic.half_circle;rotation=-180;strokeWidth=2;fillColor=none;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="51.25" y="107.5" width="25" height="20" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-34" value="<font style="font-size: 11px;">3 - RXD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#CCCC00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="25" y="30" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-35" value="<span style="font-size: 11px;"><font color="#007fff">6 - VBAT</font></span>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#CCCC00;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-25">
<mxGeometry x="27.5" y="90" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-36" value="6-Pin-Julet male" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-170" y="132" width="440" height="30" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-37" value="<font style="font-size: 11px;">1 - TXD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=#FF0000;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="205" y="77.5" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-38" value="<font style="font-size: 11px;">2 - GND</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="205" y="40" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-39" value="<font color="#00ad00" style="font-size: 11px;">5 - VCC</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-1.25" y="77.5" width="75" height="10" as="geometry" />
</mxCell>
<mxCell id="tR3VETBykpzzzQw2HGaD-40" value="<font color="#787878" style="font-size: 11px;">4 - SD</font>" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=9;fontColor=default;" vertex="1" parent="tR3VETBykpzzzQw2HGaD-24">
<mxGeometry x="-1.25" y="40" width="75" height="10" as="geometry" />
</mxCell>
</root>
</mxGraphModel>
</diagram>
</mxfile>
| 192,008 | Common Lisp | .l | 67 | 2,856.820896 | 185,608 | 0.949844 | aka13-404/VSETT-LISP | 15 | 5 | 2 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 3ba866924b5f9fc982c575b77e744ce162cf745443400a6abb3b74a38a4144fe | 7,664 | [
-1
] |
7,679 | package.lisp | outergod_cl-heredoc/test/package.lisp | ;;;; cl-heredoc - package.lisp
;;;; Copyright (C) 2009, 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-user)
(defpackage :cl-heredoc-test
(:use :cl :cl-heredoc :stefil)
(:export :all))
(in-package :cl-heredoc-test)
(in-root-suite)
(defsuite all)
| 966 | Common Lisp | .lisp | 22 | 42.545455 | 74 | 0.724468 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 5e4550d3ebef9a573d512fcc9a3e913c71b303fb83eb40ab0a9b5cd2a4698851 | 7,679 | [
-1
] |
7,680 | ring-buffer.lisp | outergod_cl-heredoc/test/ring-buffer.lisp | ;;;; cl-heredoc - ring-buffer.lisp
;;;; Copyright (C) 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-heredoc)
(shadowing-import
'(new-ring-buffer ring-buffer ring-buffer-clear
ring-buffer-end ring-buffer-flush ring-buffer-insert
ring-buffer-new ring-buffer-next ring-buffer-p
ring-buffer-pop ring-buffer-reset ring-buffer-start
ring-buffer-used ring-buffer-vector rbref
make-ring-buffer)
:cl-heredoc-test)
(in-package :cl-heredoc-test)
(in-suite all)
(defsuite ring-buffer)
(in-suite ring-buffer)
(deftest test-new-ring-buffer (length)
(let ((ring-buffer (new-ring-buffer length)))
(prog1 ring-buffer
(is (ring-buffer-p ring-buffer))
(is (vectorp (ring-buffer-vector ring-buffer)))
(is (= length (length (ring-buffer-vector ring-buffer)))))))
(deftest ring-buffer-creation ()
(dotimes (length 10)
(test-new-ring-buffer length)))
(deftest test-rbref ()
(let ((ring-buffer (make-ring-buffer :vector (make-array 5 :element-type 'character))))
(setf (rbref ring-buffer 5) #\f
(rbref ring-buffer 6) #\n
(rbref ring-buffer 7) #\o
(rbref ring-buffer 8) #\r
(rbref ring-buffer 9) #\d)
(is (string= "fnord" (ring-buffer-vector ring-buffer)))
(is (char= #\f (rbref ring-buffer 10)))
(is (char= #\n (rbref ring-buffer 11)))
(is (char= #\o (rbref ring-buffer 12)))
(is (char= #\r (rbref ring-buffer 13)))
(is (char= #\d (rbref ring-buffer 14)))))
;;; I'm too lazy to write more tests right now
| 2,219 | Common Lisp | .lisp | 51 | 40.058824 | 89 | 0.690741 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | eeaa297fdd0f5b19ae3566ec865a9703907ffcfa20c4f6432b889bc632c00274 | 7,680 | [
-1
] |
7,681 | package.lisp | outergod_cl-heredoc/src/package.lisp | ;;;; cl-heredoc - package.lisp
;;;; Copyright (C) 2009, 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-user)
(defpackage :cl-heredoc
(:use :cl)
(:export :read-heredoc :read-until-match))
| 905 | Common Lisp | .lisp | 19 | 46.315789 | 74 | 0.723982 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 24738f1e9aa3e5e26887d6ccdcc4f6fdc76da767cad0aafeddb7729241d49731 | 7,681 | [
-1
] |
7,682 | ring-buffer.lisp | outergod_cl-heredoc/src/ring-buffer.lisp | ;;;; cl-heredoc - ring-buffer.lisp
;;;; Copyright (C) 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-heredoc)
;;; Operations on ring buffers, as described by Paul Graham in ANSI Common Lisp.
(defstruct ring-buffer
"Structure defining ring buffers utilizing a simple VECTOR of fixed size and
four indices:
START: Index of first live value
END: Index of last live value
USED: Beginning of current match
NEW: End of current match"
vector (start -1) (used -1) (new -1) (end -1))
(defun new-ring-buffer (length)
"new-ring-buffer length => ring-buffer
Create a new RING-BUFFER containing a simple character vector of fixed size
LENGTH."
(make-ring-buffer :vector (make-array length :element-type 'character)))
(defun rbref (buffer index)
"rbref buffer index => character or #\Nul
Return character stored at INDEX in ring BUFFER."
(char (ring-buffer-vector buffer)
(mod index (length (ring-buffer-vector buffer)))))
(defun (setf rbref) (value buffer index)
"setf (rbref buffer index) value => value
SETF for RBREF. If INDEX > LENGTH of BUFFER, start over at the beginning."
(setf (char (ring-buffer-vector buffer)
(mod index (length (ring-buffer-vector buffer))))
value))
(defun ring-buffer-insert (buffer value)
"ring-buffer-insert buffer value => value
Increment END of BUFFER inserting VALUE at the new index."
(setf (rbref buffer (incf (ring-buffer-end buffer)))
value))
(defun ring-buffer-reset (buffer)
"ring-buffer-reset buffer => end-index
Reset match beginning/end indices USED and NEW in BUFFER to START and END."
(setf (ring-buffer-used buffer) (ring-buffer-start buffer)
(ring-buffer-new buffer) (ring-buffer-end buffer)))
(defun ring-buffer-pop (buffer)
"ring-buffer-pop buffer => character
Increment START of BUFFER returning VALUE at the new index. Additionally, reset
the BUFFER match indices."
(prog1
(rbref buffer (incf (ring-buffer-start buffer)))
(ring-buffer-reset buffer)))
(defun ring-buffer-next (buffer)
"ring-buffer-next buffer => character or nil
Return next match character incrementing USED in BUFFER or simply NIL if none
are left."
(when (< (ring-buffer-used buffer) (ring-buffer-new buffer))
(rbref buffer (incf (ring-buffer-used buffer)))))
(defun ring-buffer-clear (buffer)
"ring-buffer-clear buffer => -1
Reset all indices of BUFFER to their initial state."
(setf (ring-buffer-start buffer) -1
(ring-buffer-used buffer) -1
(ring-buffer-new buffer) -1
(ring-buffer-end buffer) -1))
(defun ring-buffer-flush (buffer)
"ring-buffer-flush buffer => string
Flush all unused characters in BUFFER."
(with-output-to-string (out)
(do ((index (1+ (ring-buffer-used buffer)) (1+ index)))
((> index (ring-buffer-end buffer)))
(write-char (rbref buffer index) out))))
| 3,566 | Common Lisp | .lisp | 78 | 42.641026 | 80 | 0.724337 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 0337739af6b8355fe06c22096884a7ffe4745725b2e26eb5d8a0ca43bce1abe7 | 7,682 | [
-1
] |
7,683 | heredoc.lisp | outergod_cl-heredoc/src/heredoc.lisp | ;;;; cl-heredoc - heredoc.lisp
;;;; Copyright (C) 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-heredoc)
(defun read-until-match (stream terminal)
"read-until-match stream terminal => string
Read characters from STREAM until a sequence equal to string TERMINAL is read.
Return all characters read as string omitting TERMINAL itself. Signal error upon
EOF."
(with-output-to-string (out)
(do* ((match-length (length terminal))
(buffer (new-ring-buffer match-length))
(buffer-char nil)
(char (read-char stream t :eof t)
(or (setf buffer-char (ring-buffer-next buffer))
(read-char stream t :eof t)))
(match-pos 0))
((eql char :eof))
(cond ((char= char (char terminal match-pos))
(when (= (incf match-pos) match-length)
(return))
(unless buffer-char
(ring-buffer-insert buffer char)))
((zerop match-pos)
(write-char char out)
(when buffer-char
(ring-buffer-pop buffer)))
(t
(unless buffer-char
(ring-buffer-insert buffer char))
(write-char (ring-buffer-pop buffer) out)
(setf match-pos 0))))))
(defun read-heredoc (stream char arg)
"read-heredoc stream char arg => string
Return string from STREAM up to the point where the string read first until CHAR
is encountered. All evaluation is completely turned off so no quoting is
required at all.
Example:
CL-USER> (set-dispatch-macro-character #\# #\> #'cl-heredoc:read-heredoc)
CL-USER> #>eof>Write whatever (you) \"want\"!eof => Write whatever (you) \"want\"!"
(declare (ignore arg))
(read-until-match stream (read-until-match stream (string char))))
| 2,493 | Common Lisp | .lisp | 54 | 39.888889 | 83 | 0.659408 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 6ffb35c5dae1a731037357172a95f851753bfac7a8bdc581b6d84c340c753785 | 7,683 | [
-1
] |
7,684 | cl-heredoc.asd | outergod_cl-heredoc/cl-heredoc.asd | ;;;; cl-heredoc - cl-heredoc.asd
;;;; Copyright (C) 2009, 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-user)
(asdf:defsystem :cl-heredoc
:description "Common Lisp reader heredoc dispatcher"
:version "0.1.0"
:author "Alexander Kahl <[email protected]>"
:license "GPLv3+"
:depends-on ()
:components
((:module "src"
:serial t
:components
((:file "package")
(:file "ring-buffer")
(:file "heredoc")))))
| 1,356 | Common Lisp | .asd | 29 | 37.275862 | 74 | 0.593208 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 4f2fbf1c7e5143a9a544a531b2335191a235f703a868da992b1b646315a8ad9f | 7,684 | [
-1
] |
7,685 | cl-heredoc-test.asd | outergod_cl-heredoc/cl-heredoc-test.asd | ;;;; cl-heredoc - cl-heredoc-test.asd
;;;; Copyright (C) 2009, 2010 Alexander Kahl <[email protected]>
;;;; This file is part of cl-heredoc.
;;;; cl-heredoc is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; cl-heredoc is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(in-package :cl-user)
(asdf:defsystem :cl-heredoc-test
:description "cl-heredoc test package."
:version "0.0.1"
:author "Alexander Kahl <[email protected]>"
:license "GPLv3+"
:depends-on (:cl-heredoc :stefil)
:components
((:module "test"
:serial t
:components
((:file "package")
(:file "ring-buffer")))))
| 1,328 | Common Lisp | .asd | 28 | 38.607143 | 74 | 0.605547 | outergod/cl-heredoc | 15 | 6 | 1 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c13b7db595b94db85f52b5b90a94261d50928c915249d9db1df744550143a58a | 7,685 | [
-1
] |
7,708 | png-package.lisp | ljosa_cl-png/png-package.lisp | (in-package #:cl-user)
(defpackage #:png
(:documentation "Read and write PNG (Portable Network Graphics) files.")
(:use #:common-lisp #:cffi #:image)
(:export
#:image
#:8-bit-image
#:16-bit-image
#:grayscale-image
#:grayscale-alpha-image
#:rgb-image
#:rgb-alpha-image
#:make-image
#:copy-image
#:image-height
#:image-width
#:image-channels
#:image-bit-depth
#:decode
#:decode-file
#:encode
#:encode-file
#:decode-bmp
#:decode-bmp-file
))
| 505 | Common Lisp | .lisp | 25 | 16.52 | 74 | 0.645094 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 12f79d7f6297a26e31664b2620ad727a8e27f32d5662d1bd8422726097690e5f | 7,708 | [
-1
] |
7,709 | example.lisp | ljosa_cl-png/example.lisp | (defpackage #:png-example
(:use #:common-lisp)
(:export #:rotate))
(in-package #:png-example)
(defun rotate (input-pathname output-pathname)
"Read a PNG image, rotate it 90 degrees, and write it to a new file."
(let* ((old (with-open-file (input input-pathname
:element-type '(unsigned-byte 8))
(png:decode input)))
(new (png:make-image (png:image-width old)
(png:image-height old)
(png:image-channels old)
(png:image-bit-depth old)))
(m (png:image-width old)))
(dotimes (i (png:image-height new))
(dotimes (j (png:image-width new))
(dotimes (k (png:image-channels new))
(setf (aref new i j k) (aref old j (- m i 1) k)))))
(with-open-file (output output-pathname :element-type '(unsigned-byte 8)
:direction :output :if-exists :supersede)
(png:encode new output))))
| 849 | Common Lisp | .lisp | 21 | 35.428571 | 78 | 0.650121 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 1a7b337292ef88d36e46be4ae7d5523e0c54d05fd7052833607b972c09ed428e | 7,709 | [
-1
] |
7,710 | bmp.lisp | ljosa_cl-png/bmp.lisp | (defpackage #:bmp
(:use #:common-lisp #:image)
(:export #:decode #:encode))
(in-package #:bmp)
(defun read-u2le (in)
"Reads 2 unsigned BYTES in little-endian from IN stream without
testing for end of file."
(let ((u 0))
(setf (ldb (byte 8 0) u) (read-byte in))
(setf (ldb (byte 8 8) u) (read-byte in))
u))
(defun read-u4le (in)
"Reads 4 unsigned BYTES in little-endian from IN stream without
testing for end of file."
(let ((u 0))
(setf (ldb (byte 8 0) u) (read-byte in))
(setf (ldb (byte 8 8) u) (read-byte in))
(setf (ldb (byte 8 16) u) (read-byte in))
(setf (ldb (byte 8 24) u) (read-byte in))
u))
(defun write-u2le (out u)
"Writes 2 unsigned BYTES in little-endian to OUT stream."
(write-byte (ldb (byte 8 0) u) out)
(write-byte (ldb (byte 8 8) u) out))
(defun write-u4le (out u)
"Writes 4 unsigned BYTES in little-endian to OUT stream."
(write-byte (ldb (byte 8 0) u) out)
(write-byte (ldb (byte 8 8) u) out)
(write-byte (ldb (byte 8 16) u) out)
(write-byte (ldb (byte 8 24) u) out))
(define-condition unhandled-compression ()
((mode :initarg :mode :reader unhandled-compression-mode))
(:report (lambda (condition stream)
(format stream "Unhandled BMP bitmap compression mode ~a~%"
(unhandled-compression-mode condition)))))
(define-condition unhandled-bitcount ()
((bitcount :initarg :bitcount :reader unhandled-bitcount-bitcount))
(:report (lambda (condition stream)
(format stream "Unhandled BMP bitcount ~a~%"
(unhandled-bitcount-bitcount condition)))))
(defun decode (input &key bgr flip strip-alpha)
"Reads an image in BMP format from input and returns an array of
type IMAGE. The bit depth of the returned IMAGE will be either 8 or
16.
Setting FLIP will flip the image vertically.
Setting STRIP-ALPHA will strip an alpha channel, if present.
Setting BGR will leave the channels ordered as read from the BMP
stream. That is, in BGR or BGRA order, rather than swapping them to
RGB or RGBA order normal to IMAGE).
The current version will decode 24-bit RGB and 32-bit ARGB BMP
streams. Compressed formats are not currently supported and will
signal an error.
Signals an error if reading the image fails."
;; Check for "BM" signature at beginning
(unless (= #x4d42 (read-u2le input))
(error "~s Not a BMP bitmap image stream" input))
;; Read rest of header
(let* ((file-sz (read-u4le input))
(reserve (read-u4le input))
(raster-data-offset (read-u4le input))
(sz (read-u4le input))
(cols (read-u4le input))
(rows (read-u4le input))
(planes (read-u2le input))
(bitcount (read-u2le input))
(compression (read-u4le input))
(image-sz (read-u4le input))
(ppm (list (read-u4le input) (read-u4le input)))
(colors (list (read-u4le input) (read-u4le input)))
(current-offset 54))
(declare (ignorable reserve sz planes ppm colors))
;; Check if we can decode this stream
(unless (= compression 0)
(error 'unhandled-compression :mode compression))
(unless (member bitcount '(8 24 32))
(error 'unhandled-bitcount :bitcount bitcount))
;; Note: the image-sz is only non-zero when compression is being
;; used. The image size should be calculated from the filesize
;; and the raster-data-offset, both of which must be accurate.
(setf image-sz (- file-sz raster-data-offset))
(let* ((channels (floor image-sz (* rows cols)))
(bit-depth (/ bitcount channels))
(stripping-alpha (and strip-alpha (= channels 4)))
(chan-loop-lim (if stripping-alpha (1- channels) channels))
(image (make-image rows cols
(if stripping-alpha 3 channels)
(if (= 16 bit-depth) 16 8)))
(npad (mod (* channels cols) 4))
(bgridx (make-array channels)))
;; Set up BGR channel swap index array
(dotimes (c channels) (setf (aref bgridx c) c))
(when (and (not bgr) (>= channels 3))
(setf (aref bgridx 0) 2)
(setf (aref bgridx 2) 0))
;; Fix npad
(when (< 0 npad) (setf npad (- 4 npad)))
;; Change some values to reflect stripping of alpha
(when stripping-alpha
(setf bitcount 24
image-sz (* 24/32 image-sz))
(setf file-sz (+ image-sz raster-data-offset)))
#|
(format t "~& dims: ~ax~a~%" rows cols)
(format t " bitcount: ~a~%" bitcount)
(format t " compression: ~a~%" compression)
(format t " file size: ~a image size:~a~%" file-sz image-sz)
(format t "raster-offset: ~x~%" raster-data-offset)
(format t " npad:~a~%" npad)
(format t " bgridx:~s~%" bgridx)
|#
;; Read palette if there is one
(when (> raster-data-offset current-offset)
(let ((table-size (- raster-data-offset current-offset)))
;; (format t " table-size: ~d~%" table-size)
(dotimes (r table-size)
(read-byte input))))
;; Read pixel data
(dotimes (row (image-height image))
(dotimes (col (image-width image))
(dotimes (chan chan-loop-lim)
(setf (aref image
(if flip (- rows row 1) row)
col
(aref bgridx chan)) (read-byte input)))
(when stripping-alpha
(read-byte input)))
(dotimes (c npad)
(read-byte input)))
image)))
(defun decode-file (pathname &key flip bgr)
"Reads file PATHNAME, decodes as BMP file and returns IMAGE."
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(bmp:decode input :flip flip :bgr bgr)))
(defun encode (image output &key flip (xppi 72) (yppi 72)
xppm yppm (reserve 0) strip-alpha bgr)
"Writes IMAGE in BMP format to OUTPUT.
Flips image vertically if FLIP set. XPPI and YPPI specify pixels per
inch Strips alpha channel if STRIP-ALPHA is set (and there is one) - in
other words, encodes ARGB as RGB.
The current version only encodes RGB and ARGB BMP files (24 and 32 bit
pixels, respectively). Paletted versions signal an error.
Signals an error if writing the image fails."
;; Notes:
;; reserve: 4-bytes that can be set by caller arbitrarily.
;;
;; compression: 0= BI_RGB (none: most common)
;; 1= BI_RLE8 palettized (8-bits/pixel)
;; 2= BI_RLE4 palettized (4-bits/pixel)
;; 3= BI_BITFIELDS (16,32-bits/pixel bitmaps)
;; 4= BI_JPEG (not supported)
;; 5= BI_PNG (not supported)
;;
;; xppm,yppm: horizontal,vertical resolution in pixels/meter
;;
;; colors_used: 0 defaults to 2**n
;; colors_important is generally ignored
;;
(check-type image (or rgb-image grayscale-image))
(let ((raster-data-offset (if (/= 1 (image-channels image)) 54 (+ 54 1024)))
(sz 40)
(planes 1)
(compression 0)
(imagesize 0)
(colors-used 0)
(colors-important 0)
(stripping-alpha (and strip-alpha (= 4 (image-channels image)))))
;; Convert the resolution if necessary
(unless (numberp xppm)
(setf xppm (floor xppi 0.0254)))
(unless (numberp yppm)
(setf yppm (floor yppi 0.0254)))
;; Rows of pixels are padded out to 4-byte boundaries, so we have
;; to calculate the number of pad bytes
(let* ((channels (if stripping-alpha 3 (image-channels image)))
(bitcount (* channels (image-bit-depth image)))
(bytes/pixel (/ bitcount 8))
(bytes/row (* bytes/pixel (image-width image) channels))
(npad (mod bytes/row 4))
(nbytes (* (image-height image)
(+ npad (* channels
(image-width image)))))
(bgridx (make-array channels))
(filesize (+ nbytes raster-data-offset)))
;; Set up BGR channel swap index array
(dotimes (c channels) (setf (aref bgridx c) c))
(when (and (not bgr) (>= channels 3))
(setf (aref bgridx 0) 2)
(setf (aref bgridx 2) 0))
;; Fix npad
(when (and (= channels 1) (< 0 npad))
(setf npad (- 4 npad)))
;; Write "BM" signature
(write-u2le output 19778)
;; Write primary header
(write-u4le output filesize)
(write-u4le output reserve)
(write-u4le output raster-data-offset)
;; Write DIB header
(write-u4le output sz)
(write-u4le output (image-width image))
(write-u4le output (image-height image))
(write-u2le output planes)
(write-u2le output bitcount)
(write-u4le output compression)
(write-u4le output imagesize)
(write-u4le output xppm)
(write-u4le output yppm)
(write-u4le output colors-used)
(write-u4le output colors-important)
;; Write color table if required
(cond ((member bitcount '(8)) ; bogus color table for grayscale images
(dotimes (n 256)
(dotimes (c 3)
(write-byte n output))
(write-byte 0 output)))
((member bitcount '(24 32))) ; don't need one
(t (error 'unhandled-bitcount :bitcount bitcount)))
;; Write raster data
(dotimes (row (image-height image))
(dotimes (col (image-width image))
(dotimes (chan channels)
(write-byte (aref image
(if flip (- (image-height image) row 1) row)
col
(aref bgridx chan))
output)))
(dotimes (c npad)
(write-byte 0 output))))))
(defun encode-file (image pathname &key flip strip-alpha bgr)
"Encodes IMAGE as BMP and writes to PATHNAME."
(with-open-file (output pathname :element-type '(unsigned-byte 8)
:direction :output :if-exists :supersede)
(bmp:encode image output :flip flip :strip-alpha strip-alpha :bgr bgr)))
| 10,166 | Common Lisp | .lisp | 233 | 35.987124 | 78 | 0.604623 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 3f5d31ebc91e625bf64a13500a28e552ab889ce503832b011315135983f0a719 | 7,710 | [
-1
] |
7,711 | image.lisp | ljosa_cl-png/image.lisp | ;;; TODO:
;;; * The displacement messes up the type inference, so making image
;;; operations efficient is a pain. Should see if I can just pass
;;; the 3-D array to the C functions.
(defpackage #:image
(:documentation "Image representation and manipulation.")
(:use #:common-lisp)
(:export
;; image.lisp
#:image
#:8-bit-image
#:16-bit-image
#:grayscale-image
#:grayscale-alpha-image
#:rgb-image
#:rgb-alpha-image
#:transparent-image
#:opaque-image
#:make-image
#:copy-image
#:image-height
#:image-width
#:image-channels
#:image-alpha
#:image-bit-depth
;; ops.lisp
#:mismatched-image-types
#:mismatched-image-sizes
#:mismatched-image-dims
#:make-image-like
#:size
#:dims
#:fillv
#:channel-min
#:channel-max
#:intensity-max
#:norm2
#:rotate
#:flip
#:mirror
#:add
#:add*
#:subtract
#:subtract*
#:threshold-filter
#:binary-morphological-filter
#:erosion-filter
#:dilation-filter
#:majority-filter
#:open-filter
#:close-filter
#:move-towards
#:convolve))
(in-package #:image)
(deftype 8-bit-image (&optional height width channels)
"An IMAGE with element type (UNSIGNED-BYTE 8)."
`(and (simple-array (unsigned-byte 8) (,height ,width ,channels))))
(deftype 16-bit-image (&optional height width channels)
"An IMAGE with element type (UNSIGNED-BYTE 16)."
`(and (simple-array (unsigned-byte 16) (,height ,width ,channels))))
(deftype image (&optional height width channels)
"A three-dimensional array of (unsigned-byte 8) or (unsigned-byte
16). In the current version, an IMAGE is displaced to a
one-dimensional SIMPLE-ARRAY with the same total number of elements,
but applications should not rely on this implementation detail, as it
is likely to change in future versions. The functions MAKE-IMAGE,
DECODE, COPY-IMAGE, 8-BIT-IMAGE, AND 16-BIT-IMAGE return IMAGEs.
The three dimensions represent row, column, and channel. In other
words, (aref image i j k) is the intensity in the k-th channel of the
pixel in the i-th row and j-th column of image."
`(or (8-bit-image ,height ,width ,channels)
(16-bit-image ,height ,width ,channels)))
(defun even-channels-p (image)
(evenp (array-dimension image 2)))
(deftype transparent-image (&optional height width)
"An IMAGE with either two or four channels (i.e. has an alphs
channel)."
`(and (image ,height ,width)
(satisfies even-channels-p)))
(deftype opaque-image (&optional height width)
"An IMAGE with either 1 or 3 channels"
`(and (image ,height ,width)
(not (satisfies even-channels-p))))
(defun color-channels-p (image)
(> (array-dimension image 2) 2))
(deftype rgb-image (&optional height width)
"An IMAGE with either three or four channels."
`(and (image ,height ,width)
(satisfies color-channels-p)))
(defun color-and-alpha-channels-p (image)
(= (array-dimension image 2) 4))
(deftype rgb-alpha-image (&optional height width)
"An IMAGE with exactly four channels."
`(and (image ,height ,width)
(satisfies color-and-alpha-channels-p)))
(defun grayscale-channels-p (image)
(<= (array-dimension image 2) 2))
(deftype grayscale-image (&optional height width)
"An IMAGE with either one or two channels."
`(and (image ,height ,width)
(satisfies grayscale-channels-p)))
(defun grayscale-alpha-channels-p (image)
(= (array-dimension image 2) 2))
(deftype grayscale-alpha-image (&optional height width)
"An IMAGE with exactly two channels."
`(and (image ,height ,width)
(satisfies grayscale-alpha-channels-p)))
(defun make-shareable-array (&rest args)
#+(or lispworks3 lispworks4 lispworks5.0)
(sys:in-static-area
(apply #'make-array args))
#-(or lispworks3 lispworks4 lispworks5.0)
(apply #'make-array
#+(or lispworks allegro) :allocation
#+lispworks :static #+allegro :static-reclaimable
args))
(defun make-image (height width channels &optional bit-depth)
"Make a new IMAGE of the specified height, width, and number of
channels. The image will be an 8-bit-image or a 16-bit-image depending
on the value of byte-size. Makes an 8-BIT-IMAGE if BIT-DEPTH is 8 or
NIL and a 16-BIT-IMAGE if BIT-DEPTH is 16. The contents of the image
are undefined."
(make-shareable-array (list height width channels)
:element-type (ecase bit-depth
((8 nil) '(unsigned-byte 8))
(16 '(unsigned-byte 16)))))
(defun image-height (image)
"The height of image, i.e., the number of rows."
(array-dimension image 0))
(defun image-width (image)
"The width of IMAGE, i.e., the number of columns."
(array-dimension image 1))
(defun image-channels (image)
"The number of channels in IMAGE. Grayscale images have one
channel, whereas RGB images have three."
(array-dimension image 2))
(defun image-alpha (image)
"Returns T if there is an alpha channel, NIL otherwise."
(evenp (array-dimension image 2)))
(defun image-bit-depth (image)
"Returns the bit-depth of the image, i.e., the number of bits in the
byte representing each sample. The bit depth is 8 or 16, depending on
whether the image is an 8-bit-image or a 16-bit-image, respectively."
(etypecase image
(8-bit-image 8)
(16-bit-image 16)))
(defun copy-image (image)
"Creates a copy of IMAGE. The elements of the new image are the same
as the corresponding elements of IMAGE, and the new image has the same
height, width, number of channels, and bit depth as IMAGE."
(let ((new (make-image (image-height image) (image-width image)
(image-channels image) (image-bit-depth image))))
(dotimes (i (array-total-size image) new)
(setf (row-major-aref new i) (row-major-aref image i)))))
(defun 8-bit-image (image)
"If IMAGE is an 8-BIT-IMAGE, return it or a copy of it. If IMAGE is
a 16-BIT-IMAGE, return an 8-BIT-IMAGE that has the same width, height,
and number of channels as image, but where each element is the
corresponding element in image divided by 257 and rounded to the
nearest integer. The effect of this division is to compress the
dynamic range of the image so as to fit within the smaller bit depth."
(etypecase image
(8-bit-image image)
(16-bit-image
(let ((new (make-image (image-height image) (image-width image)
(image-channels image) 8)))
(dotimes (i (array-total-size image) new)
(setf (row-major-aref new i) (round (row-major-aref image i) 257)))))))
(defun 16-bit-image (image)
"If IMAGE is a 16-BIT-IMAGE, return it or a copy of it. If IMAGE is
an 8-BIT-IMAGE, return a 16-BIT-IMAGE that has the same width, height,
and number of channels as IMAGE, but where each element is the
corresponding element in image multiplied by 257. The effect of this
multiplication is to stretch the dynamic range of the image to utilize
the increased bit depth."
(etypecase image
(16-bit-image image)
(8-bit-image
(let ((new (make-image (image-height image) (image-width image)
(image-channels image) 16)))
(dotimes (i (array-total-size image) new)
(setf (row-major-aref new i) (* 257 (row-major-aref image i))))))))
(defun grayscale-image (image)
"If IMAGE is a GRAYSCALE-IMAGE, return it, otherwise return a
GRAYSCALE-IMAGE of the same width and height whose corresponding
elements are the average of the channel intensities of IMAGE.
Strip out any alpha channel present."
(flet ((convert ()
(let* ((bit-depth (image-bit-depth image))
(gray (make-image (image-height image) (image-width image)
1 bit-depth))
(tp `(unsigned-byte ,bit-depth)))
(dotimes (h (image-height image) gray)
(dotimes (w (image-width image))
;; average the RGB channel intensities
(let ((avg (+ (coerce (aref image h w 0) 'float)
(coerce (aref image h w 1) 'float)
(coerce (aref image h w 2) 'float))))
(setf (aref gray h w 0) (coerce (floor avg 3) tp)))))))
(strip ()
(let ((gray (make-image (image-height image) (image-width image)
1 (image-bit-depth image))))
(dotimes (h (image-height image) gray)
(dotimes (w (image-width image))
(setf (aref gray h w 0) (aref image h w 0)))))))
(etypecase image
(grayscale-alpha-image (strip))
(grayscale-image image)
(t (convert)))))
(defun grayscale-alpha-image (image)
"If IMAGE is a GRAYSCALE-ALPHA-IMAGE, return it, otherwise return a
GRAYSCALE-ALPHA-IMAGE of the same width and height whose corresponding
elements are the average of the channel intensities of IMAGE.
Add an alpha channel if needed."
(flet ((convert ()
(let* ((bit-depth (image-bit-depth image))
(gray (make-image (image-height image) (image-width image)
2 bit-depth))
(tp `(unsigned-byte ,bit-depth))
(use-this-alpha (cond
((image-alpha image) nil)
((= bit-depth 8) 255)
((= bit-depth 16) 65535))))
(dotimes (h (image-height image) gray)
(dotimes (w (image-width image))
;; average the RGB channel intensities
(let ((avg (+ (coerce (aref image h w 0) 'float)
(coerce (aref image h w 1) 'float)
(coerce (aref image h w 2) 'float))))
(setf (aref gray h w 0) (coerce (floor avg 3) tp)
(aref gray h w 1) (or use-this-alpha
(aref image h w 3))))))))
(add-alpha ()
(let* ((bit-depth (image-bit-depth image))
(gray (make-image (image-height image) (image-width image)
2 bit-depth))
(use-this-alpha (cond
((= bit-depth 8) 255)
((= bit-depth 16) 65535))))
(dotimes (h (image-height image) gray)
(dotimes (w (image-width image))
(setf (aref gray h w 0) (aref image h w 0)
(aref gray h w 1) use-this-alpha))))))
(etypecase image
(grayscale-alpha-image image)
(grayscale-image (add-alpha))
(t (convert)))))
(defun rgb-image (image)
"If IMAGE is an RGB-IMAGE, return it, otherwise return an
RGB-IMAGE of the same width and height whose corresponding
elements are the grayscale value repeated as needed. Strip
out any alpha channels."
(flet ((convert ()
(let ((rgb (make-image (image-height image) (image-width image)
3 (image-bit-depth image))))
(dotimes (h (image-height image) rgb)
(dotimes (w (image-width image))
(setf (aref rgb h w 0) (aref image h w 0)
(aref rgb h w 1) (aref image h w 0)
(aref rgb h w 2) (aref image h w 0))))))
(strip ()
(let ((rgb (make-image (image-height image) (image-width image)
3 (image-bit-depth image))))
(dotimes (h (image-height image) rgb)
(dotimes (w (image-width image))
(setf (aref rgb h w 0) (aref image h w 0)
(aref rgb h w 1) (aref image h w 1)
(aref rgb h w 2) (aref image h w 2)))))))
(etypecase image
(rgb-alpha-image (strip))
(rgb-image image)
(t (convert)))))
(defun rgb-alpha-image (image)
"If IMAGE is a RGB-ALPHA-IMAGE, return it, otherwise return a
RGB-ALPHA-IMAGE of the same width and height whose corresponding
elements are the rgb elements of the original if the original is
an RGB-IMAGE and the repeated grayscale values if the original is
a GRAYSCALE image. Add an alpha channel if needed."
(flet ((convert ()
(let* ((bit-depth (image-bit-depth image))
(rgba (make-image (image-height image) (image-width image)
4 bit-depth))
(use-this-alpha (cond
((image-alpha image) nil)
((= bit-depth 8) 255)
((= bit-depth 16) 65535))))
(dotimes (h (image-height image) rgba)
(dotimes (w (image-width image))
;; average the RGB channel intensities
(setf (aref rgba h w 0) (aref image h w 0)
(aref rgba h w 1) (aref image h w 0)
(aref rgba h w 2) (aref image h w 0)
(aref rgba h w 3) (or use-this-alpha
(aref image h w 1)))))))
(add-alpha ()
(let* ((bit-depth (image-bit-depth image))
(rgba (make-image (image-height image) (image-width image)
4 bit-depth))
(use-this-alpha (cond
((= bit-depth 8) 255)
((= bit-depth 16) 65535))))
(dotimes (h (image-height image) rgba)
(dotimes (w (image-width image))
(setf (aref rgba h w 0) (aref image h w 0)
(aref rgba h w 1) (aref image h w 1)
(aref rgba h w 2) (aref image h w 2)
(aref rgba h w 3) use-this-alpha))))))
(etypecase image
(rgb-alpha-image image)
(rgb-image (add-alpha))
(t (convert)))))
| 12,925 | Common Lisp | .lisp | 311 | 35.44373 | 75 | 0.648732 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | b31396a478fd77e11e9b7fce86c75b43aa212579294243a2b990b369160ab9ef | 7,711 | [
-1
] |
7,712 | image-package.lisp | ljosa_cl-png/image-package.lisp | (in-package #:cl-user)
(defpackage #:image
(:documentation "Image representation and manipulation.")
(:use #:common-lisp)
(:export
;; image.lisp
#:image
#:8-bit-image
#:16-bit-image
#:grayscale-image
#:grayscale-alpha-image
#:rgb-image
#:rgb-alpha-image
#:transparent-image
#:opaque-image
#:make-image
#:copy-image
#:image-height
#:image-width
#:image-channels
#:image-alpha
#:image-bit-depth
;; ops.lisp
#:mismatched-image-types
#:mismatched-image-sizes
#:mismatched-image-dims
#:make-image-like
#:size
#:dims
#:fillv
#:channel-min
#:channel-max
#:intensity-max
#:norm2
#:rotate
#:flip
#:mirror
#:add
#:add*
#:subtract
#:subtract*
#:threshold-filter
#:binary-morphological-filter
#:erosion-filter
#:dilation-filter
#:majority-filter
#:open-filter
#:close-filter
#:move-towards
#:convolve
))
| 937 | Common Lisp | .lisp | 51 | 14.529412 | 59 | 0.647458 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 4c7da66f87db7069bd0fa792227c11b7c7d70ecc6060914870bfd5ab6140912c | 7,712 | [
-1
] |
7,713 | benchmark.lisp | ljosa_cl-png/benchmark.lisp |
(in-package #:png-test)
(defparameter *fall-pathname*
#+asdf (asdf:system-relative-pathname '#:png "Fall.png"))
(defun decode-fall ()
(with-open-file (input *fall-pathname* :element-type '(unsigned-byte 8))
(decode input)))
(defun time-decode (n)
(time (dotimes (i n)
(decode-fall))))
(defun time-encode (n)
(let ((im (decode-fall)))
(time
(dotimes (i n)
(with-open-file (output "/tmp/foo.png" :element-type '(unsigned-byte 8)
:direction :output :if-exists :supersede)
(encode im output))))))
(defun time-16-bit-image (n)
(let ((im (decode-fall)))
(time (dotimes (i n)
(16-bit-image im)))))
(defun time-8-bit-image (n)
(let ((im (16-bit-image (decode-fall))))
(time (dotimes (i n)
(8-bit-image im)))))
| 778 | Common Lisp | .lisp | 24 | 28.25 | 78 | 0.628533 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 188c93b6777981f3a52b2160b921d341f1de77f10f9009fe9b5b1058efa1f059 | 7,713 | [
-1
] |
7,714 | libpng.lisp | ljosa_cl-png/libpng.lisp | (in-package #:png)
#+cffi-features:darwin
(push #p"/usr/X11/lib/" cffi:*foreign-library-directories*)
#+cffi-features:darwin
(push #p"/opt/local/lib/" cffi:*foreign-library-directories*)
(define-foreign-library libpng
(:darwin "libpng.dylib")
(t (:default "libpng")))
(use-foreign-library libpng)
(defparameter +png-libpng-ver-string+ (get-png-libpng-ver-string))
;;; Foreign function definitions.
(defcfun "png_access_version_number" :uint32)
(defcfun "png_create_read_struct" :pointer
(user-png-ver :string)
(error-ptr :pointer)
(error-fn :pointer)
(warn-fn :pointer))
(defcfun "png_destroy_read_struct" :void
(png-ptr-ptr :pointer)
(info-ptr-ptr :pointer)
(end-info-ptr-ptr :pointer))
(defcfun "png_create_write_struct" :pointer
(user-png-ver :string)
(error-ptr :pointer)
(error-fn :pointer)
(warn-fn :pointer))
(defcfun "png_destroy_write_struct" :void
(png-ptr-ptr :pointer)
(info-ptr-ptr :pointer))
(defcfun "png_create_info_struct" :pointer
(png-ptr :pointer))
(defcfun "png_destroy_info_struct" :void
(png-ptr :pointer)
(info-ptr-ptr :pointer))
(defcfun "png_init_io" :void
(png-ptr :pointer)
(file :pointer))
(defcfun "png_set_read_fn" :void
(png-ptr :pointer)
(io-ptr :pointer)
(read-data-fn :pointer))
(defcfun "png_set_write_fn" :void
(png-ptr :pointer)
(io-ptr :pointer)
(write-data-fn :pointer)
(output-flush-fn :pointer))
(defcfun "png_get_io_ptr" :pointer
(png-ptr :pointer))
(defcfun "png_read_info" :void
(png-ptr :pointer)
(info-ptr :pointer))
(defcfun "png_read_png" :void
(png-ptr :pointer)
(info-ptr :pointer)
(png-transforms :int)
(params :pointer))
(defcfun "png_get_IHDR" :uint32
(png-ptr :pointer)
(info-ptr :pointer)
(width-uint32-ptr :pointer)
(height-uint32-ptr :pointer)
(bit-depth-int-ptr :pointer)
(color-type-int-ptr :pointer)
(interlace-type-int-ptr :pointer)
(compression-type-int-ptr :pointer)
(filter-type-int-ptr :pointer))
(defcfun "png_set_IHDR" :void
(png-ptr :pointer)
(info-ptr :pointer)
(width :uint32)
(height :uint32)
(bit-depth :int)
(color-type :int)
(interlace-type :int)
(compression-type :int)
(filter-type :int))
(defcfun "png_set_bgr" :void
(png-ptr :pointer))
(defcfun "png_set_palette_to_rgb" :void
(png-ptr :pointer))
(defcfun "png_set_expand_gray_1_2_4_to_8" :void
(png-ptr :pointer))
(defcfun "png_set_expand" :void
(png-ptr :pointer))
(defcfun "png_get_valid" :uint32
(png-ptr :pointer)
(info-ptr :pointer)
(flag :uint32))
(defcfun "png_set_tRNS_to_alpha" :void
(png-ptr :pointer))
(defcfun "png_set_strip_16" :void
(png-ptr :pointer))
(defcfun "png_set_strip_alpha" :void
(png-ptr :pointer))
(defcfun "png_set_swap" :void
(png-ptr :pointer))
(defcfun "png_get_rows" :pointer
(png-ptr :pointer)
(info-ptr :pointer))
(defcfun "png_set_rows" :void
(png-ptr :pointer)
(info-ptr :pointer)
(row-pointers :pointer))
(defcfun "png_read_image" :void
(png-ptr :pointer)
(row-pointers :pointer))
(defcfun "png_write_png" :void
(png-ptr :pointer)
(info-ptr :pointer)
(transforms :int)
(params :pointer))
(defcfun "memcpy" :pointer
(dest :pointer)
(source :pointer)
(n size))
;;; Input/output.
(defvar *stream*)
(defvar *buffer*)
(defun ensure-buffer-sufficient (needed)
(when (< (length *buffer*) needed)
(let ((new-length (length *buffer*)))
(loop while (< new-length needed)
do (setf new-length (* 2 new-length)))
(setf *buffer* (make-shareable-byte-vector new-length)))))
(defcallback user-read-data :void ((png-ptr :pointer) (data :pointer)
(length png-size))
(declare (ignore png-ptr))
(ensure-buffer-sufficient length)
(let ((bytes-read (read-sequence *buffer* *stream* :start 0 :end length)))
(unless (= bytes-read length)
(error "Expected to read ~D bytes, but only read ~D." length
bytes-read)))
(with-pointer-to-vector-data (buffer-ptr *buffer*)
(memcpy data buffer-ptr length)))
(defcallback user-write-data :void ((png-ptr :pointer) (data :pointer)
(length png-size))
(declare (ignore png-ptr))
(ensure-buffer-sufficient length)
(with-pointer-to-vector-data (buffer-ptr *buffer*)
(memcpy buffer-ptr data length))
(write-sequence *buffer* *stream* :start 0 :end length))
(defcallback user-flush-data :void ((png-ptr :pointer))
(declare (ignore png-ptr)))
;;; Error handling.
(defcallback error-fn :void ((png-structp :pointer) (message :string))
(declare (ignore png-structp))
(error message))
(defcallback warn-fn :void ((png-structp :pointer) (message :string))
(declare (ignore png-structp))
(error message))
;;; Encode and decode PNG files.
(defmacro with-png-struct ((var &key (direction :input)) &body body)
(let ((pointer (gensym "POINTER")))
`(let ((,var (,(ecase direction
(:input 'png-create-read-struct)
(:output 'png-create-write-struct))
+png-libpng-ver-string+ (null-pointer)
(callback error-fn) (callback warn-fn)))
(*buffer* (make-shareable-byte-vector 1024)))
(when (null-pointer-p ,var)
(error "Failed to allocate PNG write struct."))
(unwind-protect (progn ,@body)
(with-foreign-pointer (,pointer (foreign-type-size :pointer))
(setf (mem-ref ,pointer :pointer) ,var)
,(ecase direction
(:input `(png-destroy-read-struct ,pointer (null-pointer)
(null-pointer)))
(:output `(png-destroy-write-struct ,pointer
(null-pointer)))))))))
(defmacro with-png-info-struct ((var png-struct initform) &body body)
(let ((pointer (gensym "POINTER")))
`(let ((,var ,initform))
(when (null-pointer-p ,var)
(error "Failed to allocate PNG info struct."))
(unwind-protect (progn ,@body)
(with-foreign-pointer (,pointer (foreign-type-size :pointer))
(setf (mem-ref ,pointer :pointer) ,var)
(png-destroy-info-struct ,png-struct ,pointer))))))
(defun get-ihdr (png-ptr info-ptr)
(with-foreign-pointer (width (foreign-type-size :uint32))
(with-foreign-pointer (height (foreign-type-size :uint32))
(with-foreign-pointer (bit-depth (foreign-type-size :int))
(with-foreign-pointer (color-type (foreign-type-size :int))
(png-get-ihdr png-ptr info-ptr width height bit-depth
color-type (null-pointer) (null-pointer)
(null-pointer))
(values (mem-ref width :uint32) (mem-ref height :uint32)
(mem-ref bit-depth :int) (mem-ref color-type :int)))))))
(defun bytes-per-pixel (image)
(ecase (image-bit-depth image)
(16 2)
(8 1)))
(defmacro with-row-pointers ((rows-ptr image)
&body body)
(let ((row-pointers (gensym "ROW-POINTERS"))
(raw-data (gensym "RAW-DATA"))
(i (gensym "I")))
`(let ((,row-pointers (make-shareable-byte-vector
(* (image-height ,image)
(foreign-type-size :pointer)))))
(with-pointer-to-vector-data (,rows-ptr ,row-pointers)
(with-pointer-to-array-data (,raw-data ,image)
(dotimes (,i (image-height ,image))
(setf (mem-aref ,rows-ptr :pointer ,i)
(inc-pointer ,raw-data (* ,i (image-width ,image)
(image-channels ,image)
(bytes-per-pixel ,image)))))
,@body)))))
(defun grayp (color-type)
(zerop (logand color-type (lognot +png-color-mask-alpha+))))
(defun decode (input &key swapbgr preserve-alpha)
"Reads an image in PNG format from input and returns an array of
type IMAGE. If the bit depth of the PNG file is less than or equal to
8, an 8-BIT-IMAGE will be returned; otherwise, a 16-BIT-IMAGE will be
returned.
Applications that would like to receive images of consistent bit
depth (rather than 8 or 16 depending on the PNG file) can apply the
function 8-BIT-IMAGE or the function 16-BIT-IMAGE to the result of
DECODE.
Bit depths less than 8 will be converted to 8 bits when read, and bit
depths between 8 and 16 bits will be converted to 16 bits. As an
example, 2-bit PNG files contain only the pixel values 0, 1, 2, and 3.
These will be converted to 0, 85, 170, and 255, respectively, in order
to fill the dynamic range of the 8-bit image that is returned.
Swaps blue and red if SWAPBGR set.
Strips alpha channel unless PRESERVE-ALPHA is set.
Signals an error if reading the image fails."
(with-png-struct (png-ptr :direction :input)
(with-png-info-struct (info-ptr png-ptr (png-create-info-struct png-ptr))
(with-png-info-struct (end-ptr png-ptr (png-create-info-struct png-ptr))
(let ((*stream* input))
(png-set-read-fn png-ptr (null-pointer) (callback user-read-data))
(png-read-info png-ptr info-ptr)
(multiple-value-bind (width height bit-depth color-type)
(get-ihdr png-ptr info-ptr)
(when (= color-type +png-color-type-palette+)
(png-set-palette-to-rgb png-ptr))
(when (grayp color-type)
;; png-set-expand-gray-1-2-4-to-8 did nothing on CCL
;; DarwinPPC, but png-set-expand seems to work.
(png-set-expand png-ptr))
#+little-endian
(when (= bit-depth 16)
(png-set-swap png-ptr))
(unless (or preserve-alpha
(zerop (logand color-type +png-color-mask-alpha+)))
(png-set-strip-alpha png-ptr))
(when swapBGR
(png-set-bgr png-ptr))
(let* ((alphas (if (and preserve-alpha
(plusp (logand color-type
+png-color-mask-alpha+)))
1 0))
(image (make-image height width
(+ (if (grayp color-type) 1 3) alphas)
(if (= 16 bit-depth) 16 8))))
(with-row-pointers (row-pointers image)
(png-set-rows png-ptr info-ptr row-pointers)
(png-read-image png-ptr row-pointers))
image)))))))
(defun decode-file (pathname &key swapbgr)
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(decode input :swapbgr swapbgr)))
(defun encode (image output &key swapbgr)
"Writes IMAGE in PNG format to OUTPUT. The current version always
writes an 8-bit PNG file if image is an 8-BIT-IMAGE and a 16-bit PNG
file if image is an 16-BIT-IMAGE. Future versions may write PNG files
of lower bit depths than IMAGE when the least significant bits may be
trimmed without loss of precision.
Signals an error if writing the image fails."
(check-type image (or grayscale-image rgb-image))
(with-png-struct (png-ptr :direction :output)
(with-png-info-struct (info-ptr png-ptr (png-create-info-struct png-ptr))
(let ((*stream* output))
(png-set-write-fn png-ptr (null-pointer) (callback user-write-data)
(callback user-flush-data))
(png-set-ihdr png-ptr info-ptr (image-width image) (image-height image)
(image-bit-depth image)
(ecase (image-channels image)
(1 +png-color-type-gray+)
(2 +png-color-type-gray-alpha+)
(3 +png-color-type-rgb+)
(4 +png-color-type-rgb-alpha+))
+png-interlace-none+ +png-compression-type-default+
+png-filter-type-default+)
(when swapBGR
(png-set-bgr png-ptr))
(with-row-pointers (row-pointers image)
(png-set-rows png-ptr info-ptr row-pointers)
(png-write-png png-ptr info-ptr
#+little-endian +png-transform-swap-endian+
#-little-endian +png-transform-identity+
(null-pointer))))))
t)
(defun encode-file (image pathname &key swapbgr)
(with-open-file (output pathname :element-type '(unsigned-byte 8)
:direction :output :if-exists :supersede)
(encode image output :swapbgr swapbgr)))
| 11,383 | Common Lisp | .lisp | 298 | 34.063758 | 78 | 0.68358 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 042b1f0ebe0b11b705d9fbf2e68f6c6582bb5c839d039663dc6fb135780275e2 | 7,714 | [
-1
] |
7,715 | grovel.lisp | ljosa_cl-png/grovel.lisp | (flag "-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk/usr/X11/include")
(flag "-I/opt/local/include")
(include "png.h")
(in-package #:png)
(constant (+png-color-mask-palette+ "PNG_COLOR_MASK_PALETTE"))
(constant (+png-color-mask-color+ "PNG_COLOR_MASK_COLOR"))
(constant (+png-color-mask-alpha+ "PNG_COLOR_MASK_ALPHA"))
(constant (+png-color-type-palette+ "PNG_COLOR_TYPE_PALETTE"))
(constant (+png-color-type-rgb+ "PNG_COLOR_TYPE_RGB"))
(constant (+png-color-type-rgb-alpha+ "PNG_COLOR_TYPE_RGB_ALPHA"))
(constant (+png-color-type-gray+ "PNG_COLOR_TYPE_GRAY"))
(constant (+png-color-type-gray-alpha+ "PNG_COLOR_TYPE_GRAY_ALPHA"))
(constant (+png-transform-strip-16+ "PNG_TRANSFORM_STRIP_16"))
(constant (+png-transform-strip-alpha+ "PNG_TRANSFORM_STRIP_ALPHA"))
(constant (+png-transform-swap-endian+ "PNG_TRANSFORM_SWAP_ENDIAN"))
(constant (+png-compression-type-base+ "PNG_COMPRESSION_TYPE_BASE"))
(constant (+png-compression-type-default+ "PNG_COMPRESSION_TYPE_DEFAULT"))
(constant (+png-filter-type-base+ "PNG_FILTER_TYPE_BASE"))
(constant (+png-filter-type-default+ "PNG_FILTER_TYPE_DEFAULT"))
(constant (+png-transform-identity+ "PNG_TRANSFORM_IDENTITY"))
(constant (+png-interlace-none+ "PNG_INTERLACE_NONE"))
(ctype ssize "ssize_t")
(ctype size "size_t")
(ctype png-size "png_size_t")
| 1,350 | Common Lisp | .lisp | 24 | 55.166667 | 125 | 0.744713 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 3fae3a528649376e588ed418e214725e336769a8146086ff1844ee91e4268aba | 7,715 | [
-1
] |
7,716 | pnm.lisp | ljosa_cl-png/pnm.lisp | (defpackage #:pnm
(:use #:common-lisp #:image)
(:export #:decode #:encode))
(in-package #:pnm)
(defun whitespace-char-p (char)
(and (member char '(#\Space #\Newline #\Return #\Tab))
t))
(defun read-magic-number (input)
(with-output-to-string (output)
(loop
for char = (read-char input)
do (cond
((whitespace-char-p char) (loop-finish))
((char-equal #\# char) (read-line input nil nil))
(t (write-char char output)))
finally (unread-char char input))))
(defun read-whitespace (input &key (at-least 1))
(loop
for char = (read-char input nil nil)
and count from 0
do (cond
((char-equal #\# char) (read-line input nil nil))
((not (whitespace-char-p char)) (loop-finish)))
finally
(when char
(unread-char char input))
(when (< count at-least)
(error "Read only ~D whitespace characters; ~D required."
count at-least))))
(defun read-whitespace-character (input)
(let ((char (read-char input)))
(unless (whitespace-char-p char)
(error "Expected whitespace character, found ~S." char))))
(defun read-positive-integer (input)
(parse-integer
(with-output-to-string (output)
(loop
for char = (read-char input nil nil)
do (cond
((null char) (loop-finish))
((digit-char-p char) (write-char char output))
((char-equal #\# char) (read-line input nil nil))
(t (loop-finish)))
finally (when char
(unread-char char input))))))
(defun read-pnm-header (input)
"Read the header if it hasn't been read already, then return it."
(let* ((magic-number (read-magic-number input))
(type (cond ((equal magic-number "P4") 'pbm)
((equal magic-number "P5") 'pgm)
((equal magic-number "P6") 'ppm)
(t (error "Unknown magic number: ~S"
magic-number))))
(width (progn
(read-whitespace input)
(read-positive-integer input)))
(height (progn
(read-whitespace input)
(read-positive-integer input)))
(max-value (if (eq type 'pbm)
1
(progn
(read-whitespace input)
(read-positive-integer input)))))
(values magic-number width height max-value)))
(defun decode (input)
(multiple-value-bind (magic-number width height max-value)
(read-pnm-header input)
(funcall
(cond ((equal magic-number "P4") 'read-pbm)
((equal magic-number "P5")
(cond ((<= max-value 255) 'read-pgm-8)
((<= max-value 65535) 'read-pgm-16)
(t (error "Invalid max-value for PGM: ~D"
max-value))))
((equal magic-number "P6")
(cond ((<= max-value 255) 'read-ppm-8)
((<= max-value 65535) 'read-ppm-16)
(t (error "Invalid max-value for PPM: ~D" max-value))))
(t (error "Invalid magic number for PNM: ~S" magic-number)))
input width height)))
(defun read-pbm (input width height)
(let ((row (make-array (ceiling width 8)
:element-type '(unsigned-byte 8)))
(raw-data (make-array (* width height)
:element-type 'bit)))
(dotimes (y height)
(unless (= (read-sequence row input)
(length row))
(error "Failed to read ~D bytes of raw image data." (length row)))
(dotimes (x width)
(setf (aref raw-data (+ (* y width) x))
(ldb (byte 1 (- 7 (mod x 8)))
(aref row (floor x 8))))))
(make-instance 'image :raw-data raw-data
:height height :width width :bits 1 :channels 1)))
(defun read-pgm-8 (input width height)
(let ((raw-data (make-array (* width height)
:element-type '(unsigned-byte 8))))
(unless (= (read-sequence raw-data input)
(length raw-data))
(error "Failed to read ~D bytes of raw image data." (length raw-data)))
(make-instance 'image :raw-data raw-data :height height :width width
:bits 8 :channels 1)))
(defun read-pgm-16 (input width height)
(let ((raw-data (make-array (* width height)
:element-type '(unsigned-byte 16)))
(row (make-array (* width 2) :element-type '(unsigned-byte 8))))
(dotimes (y height)
(unless (= (read-sequence row input)
(length row))
(error "Failed to read ~D bytes of raw image data." (length row)))
(dotimes (x width)
(setf (aref raw-data (+ (* y width) x))
(+ (* 256 (aref row (* x 2)))
(aref row (1+ (* x 2)))))))
(make-instance 'image :raw-data raw-data :height height :width width
:bits 16 :channels 1)))
(defun read-ppm-8 (input width height)
(let ((raw-data (make-array (* width height 3)
:element-type '(unsigned-byte 8)))
(row (make-array (* width 3)
:element-type '(unsigned-byte 8))))
(dotimes (y height)
(unless (= (read-sequence row input) (length row))
(error "Failed to read ~D bytes of raw image data." (length row)))
(dotimes (x width)
(dotimes (c 3)
(setf (aref raw-data (+ (* (+ (* y width) x) 3) c))
(aref row (+ (* x 3) c))))))
(make-instance 'image :raw-data raw-data :height height :width width
:bits 8 :channels 3)))
(defun read-ppm-16 (input width height)
(let ((raw-data #1=(make-array (* width height 3)
:element-type '(unsigned-byte 16)))
(row (make-array (* width 3 2)
:element-type '(unsigned-byte 8))))
(flet ((row-ref (x c)
(let ((i (+ (* x 3) c)))
(+ (* 256 (aref row (* i 2)))
(aref row (1+ (* i 2)))))))
(dotimes (y height)
(unless (= (read-sequence row input) (length row))
(error "Failed to read ~D bytes of raw image data." (length row)))
(dotimes (x width)
(dotimes (c 3)
(setf (aref raw-data (+ (* (+ (* y width) x) 3) c))
(row-ref x c))))))
(make-instance 'image :raw-data raw-data :height height :width width
:bits 16 :channels 3)))
(defun write-pnm-header (image stream type)
(write-sequence (map 'vector #'char-code
(format nil "~A~%~D ~D~%~D~%" type (image-width image)
(image-height image)
(1- (expt 2 (image-bit-depth image)))))
stream))
(defun write-pnm-data-1 (image stream)
(dotimes (y (image-height image))
(loop
with value = 0
for x below (image-width image)
do (let ((b (mod x 8)))
(when (zerop b)
(unless (= x 0)
(write-byte value stream)
(setf value 0)))
(setf value (dpb (aref image y x)
(byte 1 (- 7 b))
value)))
finally (write-byte value stream))))
(defun write-pnm-data-8 (image stream)
(write-sequence (array-displacement image) stream))
(defun write-pnm-data-16 (image stream)
(dotimes (i (array-total-size image))
(multiple-value-bind (msb lsb) (floor (row-major-aref image i) 256)
(write-byte msb stream)
(write-byte lsb stream))))
(defun write-pnm-data (image stream)
(let ((bits (image-bit-depth image)))
(cond ((= bits 1) (write-pnm-data-1 image stream))
((<= bits 8) (write-pnm-data-8 image stream))
((<= bits 16) (write-pnm-data-16 image stream))
(t (error "Cannot write ~D-bit image as PNM." bits))))
t)
(defun encode (image stream)
(cond ((= (image-bit-depth image) 1)
(write-pnm-header image stream "P4")
(write-pnm-data image stream))
((= (image-channels image) 1)
(write-pnm-header image stream "P5")
(write-pnm-data image stream))
((= (image-channels image) 3)
(write-pnm-header image stream "P6")
(write-pnm-data image stream))
(t (error "Cannot write image with ~D bits and ~D channels as PNM."
(image-bit-depth image) (image-channels image)))))
| 8,157 | Common Lisp | .lisp | 196 | 32.530612 | 77 | 0.558942 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 5c15723522f4a888bab236c337fe981442e82f5aede55cb0597a7e326bdd0e3b | 7,716 | [
-1
] |
7,717 | compat.lisp | ljosa_cl-png/compat.lisp | (in-package #:png)
#+sbcl
(macrolet ((make-array-storage-vector ()
(let ((%array-data-vector (or (find-symbol "%ARRAY-DATA-VECTOR" :sb-kernel)
(find-symbol "%ARRAY-DATA" :sb-kernel)))) ;; renamed in sbcl 2.1.6
`(progn
(declaim (ftype (function (array) (values (simple-array * (*)) &optional)) array-storage-vector))
(defun array-storage-vector (array)
"Returns the underlying storage vector of ARRAY, which must be a non-displaced array.
In SBCL, if ARRAY is a of type \(SIMPLE-ARRAY * \(*)), it is its own storage
vector. Multidimensional arrays, arrays with fill pointers, and adjustable
arrays have an underlying storage vector with the same ARRAY-ELEMENT-TYPE as
ARRAY, which this function returns.
Important note: the underlying vector is an implementation detail. Even though
this function exposes it, changes in the implementation may cause this
function to be removed without further warning."
(sb-ext:truly-the (simple-array * (*))
(if (sb-kernel:array-header-p array)
(if (sb-kernel:%array-displaced-p array)
(error "~S cannot be used with displaced arrays. Use ~S instead."
'array-storage-vector 'array-displacement)
(,%array-data-vector array))
array)))))))
(make-array-storage-vector))
#+allegro
(defmacro with-pointer-to-array-data ((ptr-var array) &body body)
"Bind PTR-VAR to a foreign pointer to the data in VECTOR. Not safe
except with array allocated by MAKE-SHAREABLE-ARRAY and
possibly arrays of type simple-array (unsigned-byte 8) (*)."
;;; An array allocated in static-reclamable is a non-simple array in
;;; the normal Lisp allocation area, pointing to a simple array in the
;;; static-reclaimable allocation area. Therefore we have to get out
;;; the simple-array to find the pointer to the actual contents.
(let ((simple-arr (gensym "SIMPLE-ARR")))
`(excl:with-underlying-simple-vector (,array ,simple-arr)
(let ((,ptr-var (ff:fslot-address-typed :unsigned-char
:lisp ,simple-arr)))
,@body))))
#+clisp
(defmacro with-pointer-to-array-data ((ptr-var array) &body body)
"Bind PTR-VAR to a foreign pointer to the data in ARRAY."
(let ((array-var (gensym))
(type (gensym))
(nbytes (gensym))
(bytes-per-word (gensym)))
`(let* ((,array-var ,vector)
,type ,bytes-per-word)
(etypecase ,array-var
((simple-array (unsigned-byte 8)) (setq ,type :unsigned-char
,bytes-per-word 1))
((simple-array (unsigned-byte 16)) (setq ,type :unsigned-short
,bytes-per-word 2)))
(with-foreign-pointer (,ptr-var (* (array-total-size ,array-var)
,bytes-per-word)
,nbytes)
;; copy-in
(loop
for word from 0
and byte below ,nbytes by ,bytes-per-word
do (cffi-sys:%mem-set (row-major-aref ,array-var word)
,ptr-var ,type byte))
(unwind-protect (progn ,@body)
;; copy-out
(loop
for word from 0
and byte below ,nbytes by ,bytes-per-word
do (setf (row-major-aref ,array-var word)
(cffi-sys:%mem-ref ,ptr-var ,type byte))))))))
#+lispworks
(defmacro with-pointer-to-array-data ((ptr-var array) &body body)
`(progn
(assert (system:staticp ,array) `(,array)
"Array must be allocated in the static area.")
(with-pointer-to-vector-data (,ptr-var ,array) ,@body)))
#+sbcl
(defmacro with-pointer-to-array-data ((ptr-var array) &body body)
`(cffi:with-pointer-to-vector-data (,ptr-var (array-storage-vector ,array))
,@body))
#+ccl
(defmacro with-pointer-to-array-data ((ptr-var array) &body body)
(let ((v (gensym)))
`(let ((,v (ccl::array-data-and-offset ,array)))
(unless (typep ,v 'ccl::ivector)
(ccl::report-bad-arg ,v 'ccl::ivector))
(ccl::without-gcing
(ccl:with-macptrs ((,ptr-var))
(ccl::%vect-data-to-macptr ,v ,ptr-var)
,@body)))))
| 4,238 | Common Lisp | .lisp | 88 | 39.056818 | 115 | 0.613043 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 8ca90cf7546317548ded585359f765dcd2cdd02a27468bf600e5f9f34c5a22a9 | 7,717 | [
-1
] |
7,718 | wrappers.lisp | ljosa_cl-png/wrappers.lisp | (in-package #:png)
(flag "-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk/usr/X11/include")
(flag "-I/opt/local/include")
(include "png.h")
(defwrapper* "get_png_libpng_ver_string" :string () "return PNG_LIBPNG_VER_STRING;")
| 280 | Common Lisp | .lisp | 5 | 54.6 | 125 | 0.758242 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 1c392b1ac25f304e91ef823b58e93559b3362970b489bfeef2983f1966e7f044 | 7,718 | [
-1
] |
7,719 | image-test.lisp | ljosa_cl-png/test/image-test.lisp | ;;;# Unit Tests for Image Operations
;;;
;;; RUN-TESTS to run tests, either individually, multiply, or all at
;;; once:
;;;
;; (run-tests test1) ; runs one test
;; (run-tests test1 test2) ; runs two tests
;; (run-tests) ; runs all defined tests
;;;
;;;## Requirements
;;;
;;; These unit tests depend on the lisp-unit library, obtained from
;;; http://www.cliki.net/lisp-unit. The package defined in
;;; bmp-test.asd will load them.
;;;
;;; Test images are provided which must located relative to this file
;;; location as defined in *BMPIMAGES-PATHNAME* below
;;;
(defpackage #:image-test
(:use #:common-lisp #:lisp-unit #:image)
(:export #:*images-pathname*))
(in-package #:image-test)
(defparameter *images-pathname*
#+asdf (merge-pathnames "images/"
(truename (asdf:system-definition-pathname
'#:image-test))))
;;;## Utility functions
;;;
(defun make-name (bn tp)
(merge-pathnames (make-pathname :name bn :type tp) *images-pathname*))
(defun decode-pngimage (basename)
(let ((pathname (make-name basename "png")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(png:decode input))))
(defun decode-bmpimage (basename &key strip-alpha)
(let ((pathname (make-name basename "bmp")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(bmp:decode input :strip-alpha strip-alpha))))
(defun max-diff (im1 im2)
(image:intensity-max (image:subtract im1 im2)))
;;;# Basic Tests
;;;
(in-package #:image-test)
(define-test channel-order
(let ((rgb (decode-bmpimage "tagged-RGB"))
(argb (decode-bmpimage "tagged-ARGB")))
(assert-true (typep rgb 'rgb-image))
(assert-true (typep rgb 'opaque-image))
(assert-true (typep argb 'rgb-image))
(assert-false (typep argb 'opaque-image))
(assert-true (typep argb 'transparent-image))))
(define-test fill-tests
(let ((a (make-image 10 10 3)))
(assert-error 'error (image:fillv a '(99 99)))
(assert-error 'error (image:fillv a '(1 1 2 2 2)))
(image:fillv a '(99 88 77))
(assert-equalp #(99 88 77) (image:channel-max a))))
(run-tests channel-order)
(run-tests fill-tests)
;;; Scalar-Valued Functions of One Image
;;;
;;;## IMAGE-NORM2
;;;
(define-test image-norm2
(let ((a (make-image 10 10 3))
(b (make-image 10 10 3)))
(image:fillv a '(1 1 1))
(image:fillv b '(2 2 2))
(assert-equal 300 (image:norm2 a))
(assert-equal 1200 (image:norm2 b))))
(run-tests image-norm2)
;;;# Functions of One Image
;;;
;;;## IMAGE-SCALE
;;;# Functions of Two Images
;;;
;;;## IMAGE-SUB
;;;
(define-test image-sub-test
(let ((a (decode-bmpimage "intrepid-rgb"))
(b (decode-bmpimage "scene"))
(c (decode-bmpimage "intrepid-argb"))
(d (decode-bmpimage "intrepid-argb" :strip-alpha T))
(err))
(setf err (image:norm2 (image:subtract a d)))
(assert-error 'error (image:subtract a b))
(assert-error 'error (image:subtract a c))
(assert-equal 0 err)
(let* ((f (image:subtract a a))
(g (make-image-like c))
(h (make-image-like c)))
(assert-equal 0 (image:norm2 f))
(image:subtract* a d)
(assert-equal 0 (image:norm2 a))
(image:fillv g '(40 40 40 40))
(setf h (image:subtract c g))
(image:subtract* c g)
(assert-equalp c h))))
(run-tests image-sub-test)
;;; ## IMAGE-ADD
(define-test image-add-test
(let* ((a (decode-bmpimage "butterfly1"))
;; (a-maxch (image-channel-max a))
(a-maxin (image:intensity-max a))
(b (make-image-like a))
(val '(40 30 20))
(submax #(215 225 235))
(c)
(d))
(image:fillv b val)
(setf c (image:subtract a b))
(assert-equal (- a-maxin (apply #'+ val)) (image:intensity-max c))
(assert-equalp submax (image:channel-max c))
(setf d (image:add c b))
(image:subtract* d a) ; contains bottom end clipping residue
;; (format t "maxchans d = ~a~%" (image-channel-max d))
))
;; (still working on this one)
(run-tests image-add-test)
;;;# Statistical Functions
;;; | 4,180 | Common Lisp | .lisp | 121 | 30.107438 | 75 | 0.626488 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 63858967634968aaf71bcd9d04e258623531521945df114f89060e2b2e5b3289 | 7,719 | [
-1
] |
7,720 | bmp-test.lisp | ljosa_cl-png/test/bmp-test.lisp | ;;;# Unit Tests for BMP file interface
;;;
;;; RUN-TESTS to run tests, either individually, multiply, or all at
;;; once:
;;;
;; (run-tests test1) ; runs one test
;; (run-tests test1 test2) ; runs two tests
;; (run-tests) ; runs all defined tests
;;;
;;;## Requirements
;;;
;;; Depends on the lisp-unit, obtained from
;;; http://www.cliki.net/lisp-unit. The package defined in
;;; bmp-test.asd will load and run them.
;;;
;;; Test images are provided which must located as defined in
;;; *BMPIMAGES-PATHNAME* below.
;;;
(defpackage #:bmp-test
(:use #:common-lisp #:lisp-unit #:image)
(:export #:*images-pathname*))
(in-package #:bmp-test)
(defparameter *images-pathname*
#+asdf (merge-pathnames "images/"
(truename (asdf:system-definition-pathname
'#:bmp-test))))
(run-tests )
;;;## Utility functions
;;;
(defun make-name (bn tp)
(merge-pathnames (make-pathname :name bn :type tp) *images-pathname*))
(defun decode-pngimage (basename)
(let ((pathname (make-name basename "png")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(png:decode input))))
(defun decode-bmpimage (basename &key strip-alpha)
(let ((pathname (make-name basename "bmp")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(bmp:decode input :strip-alpha strip-alpha))))
(defun encode-decode (im &key strip-alpha keep-tmp)
(let ((pathname (make-name "tmp" "bmp")))
(ignore-errors (delete-file pathname))
(bmp::encode-file im pathname :strip-alpha strip-alpha)
(prog1
(bmp::decode-file pathname)
(unless keep-tmp
(delete-file pathname)))))
(defun max-diff (im1 im2)
(image:intensity-max (image:subtract im1 im2)))
;;;# Basic Tests
;;;
;;; Tests that decode function produces correct type of image and
;;; fails on those whose modes aren't supported.
(define-test image-type-test
(let ((rgb (decode-bmpimage "tagged-RGB"))
(argb (decode-bmpimage "tagged-ARGB"))
(gray (decode-bmpimage "tagged-gray")))
(assert-true (typep rgb 'rgb-image))
(assert-true (typep gray 'grayscale-image))
(assert-error 'bmp::unhandled-compression (decode-bmpimage "intrepid-xrgb"))
(assert-error 'bmp::unhandled-compression (decode-bmpimage "intrepid-r5b6g5"))
(assert-error 'bmp::unhandled-compression (decode-bmpimage "intrepid-a1r5b5g5"))
(assert-error 'bmp::unhandled-bitcount (decode-bmpimage "intrepid-x1r5b5g5"))))
;;(run-tests '(image-type-test))
;;; Test that the row padding is being handled properly. There are
;;; four cases: images whose widths modulo 4 result in 0,1,2,3.
;;;
;;; The methodology is to decode a file into an image, re-encode the
;;; image back to a file, then decode it again and compare the two
;;; decoded images.
(define-test encode-modulo-0
(let ((a (decode-bmpimage "scene")))
(assert-equal 0 (max-diff a (encode-decode a)))))
(define-test encode-modulo-1
(let ((a (decode-bmpimage "scene-w765"))
(b (decode-bmpimage "scene-bw765")))
(assert-true (typep a 'rgb-image))
(assert-equal 0 (max-diff a (encode-decode a :keep-tmp t)))
(assert-true (typep b 'grayscale-image))
(assert-equal 0 (max-diff b (encode-decode b)))))
(define-test encode-modulo-2
(let ((a (decode-bmpimage "scene-w766")))
(assert-equal 0 (image:intensity-max (image:subtract a (encode-decode a))))))
(define-test encode-modulo-3
(let ((a (decode-bmpimage "scene-w767"))
(b (decode-bmpimage "scene-bw767")))
(assert-true (typep a 'rgb-image))
(assert-equal 0 (max-diff a (encode-decode a)))
(assert-true (typep b 'grayscale-image))
(assert-equal 0 (max-diff b (encode-decode b)))))
;;(run-tests '(encode-modulo-0 encode-modulo-2))
;;(run-tests '(encode-modulo-1 encode-modulo-3))
;; (run-tests)
(define-test decode-strip-alpha
(let* ((a (decode-bmpimage "intrepid-rgb"))
(b (decode-bmpimage "intrepid-argb"))
(c (decode-bmpimage "intrepid-argb" :strip-alpha T)))
(assert-true (typep a 'rgb-image))
(assert-true (typep c 'rgb-image))
(assert-equal 0 (max-diff a c))))
(define-test encode-strip-alpha
(let* ((a (decode-bmpimage "intrepid-argb"))
(b (encode-decode a :strip-alpha T :keep-tmp T))
(c (decode-bmpimage "tmp")))
(assert-true (typep b 'rgb-image))
(assert-true (typep c 'rgb-image))
(assert-equal 0 (max-diff b c))))
;;(run-tests '(decode-strip-alpha))
;;(run-tests '(encode-strip-alpha))
| 4,569 | Common Lisp | .lisp | 109 | 37.798165 | 86 | 0.663814 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | f5becfc420813d83da7ed16aa1e0c9715580e60e17cd219681146f4887cbc007 | 7,720 | [
-1
] |
7,721 | ops-test.lisp | ljosa_cl-png/test/ops-test.lisp | ;;;# Unit Tests for Image Operations
;;;
;;;## Requirements
;;;
;;; This test suite depends on lisp-unit.lisp, obtained from
;;; http://www.cliki.net/lisp-unit, but also included herein.
;;;
;;; Everything should be loaded correctly by loading ops-test with
;;; asdf, provided the asd links have been established:
;; (asdf:oos 'asdf:load-op :ops-test)
;;; Some of the tests refer to provided images which must be located
;;; as defined in *BMPIMAGES-PATHNAME* as set below.
;;;
(defpackage #:ops-test
(:use #:common-lisp #:lisp-unit #:image #:png)
(:export #:*images-pathname*))
(in-package #:ops-test)
(defparameter *images-pathname*
#+asdf (merge-pathnames "images/"
(truename (asdf:system-definition-pathname
'#:ops-test))))
;;;## Convenience functions
(defun make-name (bn tp)
(merge-pathnames (make-pathname :name bn :type tp) *images-pathname*))
(defun decode-pngimage (basename)
(let ((pathname (make-name basename "png")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(png:decode input))))
(defun decode-bmpimage (basename &key strip-alpha)
(let ((pathname (make-name basename "bmp")))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(bmp:decode input :strip-alpha strip-alpha))))
(defun max-diff (im1 im2)
(image:intensity-max (image:subtract im1 im2)))
(defun list2array (lst)
(make-array (length lst) :initial-contents lst))
(defun fill-graded (a)
(dotimes (h (image-height a) a)
(dotimes (w (image-width a))
(dotimes (c (image-channels a))
(let ((val (+ (* (image-width a) h) w c)))
(setf (aref a h w c) val))))))
;;;# Basic Tests
;;;
;;; Basic tests are those which will subsequently be used to help
;;; verify other functions.
;;;
;;;## Accessor Tests
(define-test accessor-test
(let ((a (make-image 111 222 3)))
(assert-equal '(111 . 222) (image:size a))
(assert-equal '(111 222 3) (image:dims a))))
(run-tests accessor-test)
(defparameter *simple-set* '(((10 11 1 8) grayscale-image (99))
((12 13 1 16) grayscale-image (88))
((14 15 3 8) rgb-image (99 88 77))
((16 17 3 16) rgb-image (66 55 44))
((18 19 4 8) rgb-image (111 122 133 144))
((20 21 4 16) rgb-image (122 133 144 155))))
;;;## Test FILLV
;;;
;;; Creates an image of each type, fills it with an arbitrary pixel
;;; value, then checks to see that all are set correctly. Also checks
;;; the check function by changing one pixel.
(define-test fillv-test
(flet ((check-for-diff (im val)
(block found-diff
(dotimes (r (image-height im) NIL)
(dotimes (c (image-width im))
(dotimes (ch (image-channels im))
(unless (= (aref im r c ch) (nth ch val))
(return-from found-diff T))))))))
(dolist (tst *simple-set*)
(let ((img (apply #'make-image (car tst)))
(typ (cadr tst))
(val (caddr tst)))
(assert-true (typep img typ))
(image:fillv img val)
(assert-false (check-for-diff img val))
(decf (aref img 2 3 0))
(assert-true (check-for-diff img val))))))
(run-tests fillv-test)
;;;## Test INTENSITY-MAX and CHANNEL-MAX
;;;
;;;
(define-test max-test
(labels ((intensity (pix &optional (sum 0))
(if (null pix)
sum
(intensity (cdr pix) (+ sum (car pix))))))
(dolist (tst *simple-set*)
(let ((img (apply #'make-image (car tst)))
(val (caddr tst)))
(image:fillv img val)
(assert-equalp (list2array val) (channel-max img))
(assert-equal (intensity val) (intensity-max img))
))))
(run-tests max-test)
;;;# Functions that Modify a Single Image
;;;
;;;## SCALE
;;;
;;; TBD
;;;# Functions that Combine Images
;;;
;;;## ADD, ADD*
;;;
;;; Depends on FLIP, MIRROR, CHANNEL-MIN, CHANNEL-MAX
(defparameter *add-set* '(((5 6 1 8) grayscale-image)
((5 6 1 16) grayscale-image)
((5 6 3 8) rgb-image)
((5 6 3 16) rgb-image)
((5 6 4 8) rgba-image)
((5 6 4 16) rgba-image)))
(define-test image-add-test
(dolist (tst *add-set*)
(let* ((a (fill-graded (apply #'make-image (car tst))))
(b (flip a))
(c (add a b))
(d (image::mirror c))
(e (add c d)))
;; test non-destructive version
(assert-equalp (image::channel-min e) (channel-max e))
;; test destructive version
(add* a b)
(setf c (image::mirror a))
(add* a c)
(assert-equalp (image::channel-min a) (channel-max a)))))
(run-tests image-add-test)
(define-test image-sub-test
(dolist (tst *add-set*)
(let* ((a (fill-graded (apply #'make-image (car tst))))
(b (flip a))
(c (add a b))
(d (subtract c b)))
(assert-equalp a d)
;; test destructive version
(subtract* c b)
(assert-equalp a c))))
(run-tests image-sub-test)
;;;## MOVE-TO
;;;
(define-test image-move-to-test
(let* ((a (image:fillv (make-image 4 4 1) '(100)))
(b (image:fillv (make-image 4 4 1) '(10)))
(c (image:fillv (make-image 4 4 1) '(80)))
(d (image:fillv (make-image 4 4 1) '(30))))
(assert-equalp c (image::move-towards a b 20))
(assert-equalp d (image::move-towards b a 20))))
(run-tests image-move-to-test)
;;;# Other Scalar Valued Functions
;;;
;;;## IMAGE-NORM2
;;;
(define-test image-norm2
(let ((a (make-image 10 10 3))
(b (make-image 10 10 3)))
(image:fillv a '(1 1 1))
(image:fillv b '(2 2 2))
(assert-equal 300 (image:norm2 a))
(assert-equal 1200 (image:norm2 b))))
(run-tests image-norm2)
;;;# Edge Detector
;;;
;;; We will use a convolutional filter with this kernel:
;;;
;;; 0 -1 0
;;; -1 4 -1
;;; 0 -1 0
;;;
(defparameter *edge-kernel*
(let ((mask (make-array (list 3 3)
:element-type 'float :initial-element 0.e0)))
(setf (aref mask 0 1) -1.e0
(aref mask 1 0) -1.e0
(aref mask 1 2) -1.e0
(aref mask 2 1) -1.e0
(aref mask 1 1) 4.e0)
mask))
(print *edge-kernel*)
;; Disabled because the input file butterfly8-gray.png is missing.
#+ignore
(define-test convolve-edge
(let* ((a (png:decode-file (merge-pathnames "butterfly8-gray.png" *images-pathname*)))
(c (png:decode-file (merge-pathnames "butterfly8.png" *images-pathname*)))
(ea)
(ec))
(time
(setf ea (image::convolve a *edge-kernel* :fill '(#x7f))))
(png:encode-file ea "test-ea.png")
(time
(setf ec (image::convolve c *edge-kernel*)))
(format t "ec size:~s~%" (size ec))
(png:encode-file ec "test-ec.png")
(time
(setf ec (image::convolve c *edge-kernel* :fill '(#x7f #x7f #x7f))))
(format t "ec size:~s~%" (size ec))
(png:encode-file ec "test-ecb.png")
(assert-true (typep ec 'rgb-image))))
;;(run-tests convolve-edge)
;; (run-tests)
| 7,225 | Common Lisp | .lisp | 201 | 29.393035 | 88 | 0.578261 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 2ad07ad741cb502cc0d7fe76ff5c18a7ebb55f20caac109bd4cc2f2efeb7b381 | 7,721 | [
-1
] |
7,722 | png-test.lisp | ljosa_cl-png/test/png-test.lisp | (defpackage #:png-test
(:use #:common-lisp #:lisp-unit #:png)
(:export #:*pngsuite-pathname*))
(in-package #:png-test)
;; ASDF:SYSTEM-RELATIVE-PATHNAME only exists in very recent versions
;; of ASDF, so we'll do it this way.
(defparameter *pngsuite-pathname*
#+asdf (merge-pathnames "PngSuite/"
(truename (asdf:system-definition-pathname
'#:png-test))))
(defun decode-pngsuite (basename)
(let ((pathname (merge-pathnames (make-pathname :name basename :type "png")
*pngsuite-pathname*)))
(with-open-file (input pathname :element-type '(unsigned-byte 8))
(decode input))))
(defun encode-decode (im)
(ignore-errors (delete-file "tmp.png"))
(png::encode-file im "tmp.png")
(prog1
(png::decode-file "tmp.png")
(delete-file "tmp.png")))
(defun unused-bits (im)
"The number of least significant bits that are always zero."
(let ((x (reduce #'logior (array-displacement im))))
(loop
for bits from 0
until (or (= bits (etypecase im
(8-bit-image 8)
(16-bit-image 16)))
(not (zerop (ldb (byte 1 bits) x))))
finally (return bits))))
(define-test make-image
(let ((i8 (make-image 2 4 3))
(i16 (make-image 2 4 3 16)))
(assert-true (typep i8 '8-bit-image))
(assert-false (typep i8 '16-bit-image))
(assert-true (typep i16 '16-bit-image))
(assert-false (typep i16 '8-bit-image))
(assert-true (typep i8 'image))
(assert-true (typep i8 'rgb-image))
(assert-true (typep i16 'image))
(assert-true (typep i16 'rgb-image))
(assert-equal '(2 4 3) (array-dimensions i8))))
(define-test decode-8-bit
(let ((im (decode-pngsuite "basn0g08")))
(assert-true (typep im '8-bit-image))
(assert-equal 0 (aref im 0 0 0))
(assert-equal 255 (aref im 7 31 0))
(assert-equal #x1f (aref im 0 31 0))
(assert-equal #x1c (aref im 31 0 0))))
(define-test decode-16-bit
(let ((im (decode-pngsuite "basn0g16")))
(assert-true (typep im '16-bit-image))
(assert-equal 0 (aref im 0 0 0))
(assert-equal 65535 (aref im 2 28 0))
(assert-equal #xf700 (aref im 2 27 0))
(assert-equal #x3e00 (aref im 31 0 0))))
(defun print-image (image)
(let ((f (etypecase image
(8-bit-image "~2x ")
(16-bit-image "~4x "))))
(dotimes (i (image-height image))
(dotimes (j (image-width image))
(format t f (aref image i j 0)))
(terpri))))
(defun values-used (image)
(let ((values (make-array (typecase image
(8-bit-image 256)
(16-bit-image 65536))
:element-type 'bit
:initial-element 0)))
(dotimes (i (array-total-size image))
(setf (aref values (row-major-aref image i)) 1))
(loop for i from 0 and b across values
when (= b 1)
collect i)))
(define-test decode-4-bit
(let ((im (decode-pngsuite "basn0g04")))
(assert-true (typep im '8-bit-image))
(assert-equal #xEE (aref im 31 31 0))
(assert-equal #x77 (aref im 31 0 0))
(assert-equal #x00 (aref im 0 0 0))))
(define-test decode-2-bit
(let ((im (decode-pngsuite "basn0g02")))
(assert-true (typep im '8-bit-image))
(assert-equal #xAA (aref im 31 31 0))
(assert-equal #xFF (aref im 31 0 0))
(assert-equal #x00 (aref im 0 0 0))))
(define-test decode-1-bit
(let ((im (decode-pngsuite "basn0g01")))
(assert-true (typep im '8-bit-image))
(assert-equal #xFF (aref im 0 0 0))
(assert-equal #x00 (aref im 31 31 0))))
(define-test encode-8-bit
(let* ((a (decode-pngsuite "basn0g08"))
(b (encode-decode a)))
(assert-equalp a b)))
(define-test encode-16-bit
(let* ((a (decode-pngsuite "basn0g16"))
(b (encode-decode a)))
(assert-equalp a b)))
(define-test copy-image
(let* ((a (decode-pngsuite "basn0g08"))
(b (copy-image a)))
(assert-equalp a b)))
(define-test 16-bit-image
(let* ((a (decode-pngsuite "basn0g08"))
(b (16-bit-image a))
(c (8-bit-image b)))
(assert-equalp a c)))
| 3,929 | Common Lisp | .lisp | 110 | 31.227273 | 77 | 0.633421 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 282689fa13ef7b39b7817813762430c54be459184d80a09429ed93a916437ba8 | 7,722 | [
-1
] |
7,723 | tutorial.lisp | ljosa_cl-png/doc/tutorial.lisp | (defpackage #:tutorial
(:use #:common-lisp #:lisp-unit #:png)
(:export #:*images-pathname*))
(in-package #:tutorial)
;;;# IMAGE arrays
;;;
;;; An image is a 3-dimensional array of row, column, and channel
;;; representing pixels.
;;;
;;; The BIT-DEPTH is the size of unsigned-byte used representing the
;;; array. Currently, this is restricted to 8 or 16.
;;;
;;;## Image types
;;;
;;; The following image types are defined: 8-BIT-IMAGE, 16-BIT-IMAGE,
;;; GRAY-SCALE-IMAGE, RGB-IMAGE, ARGB-IMAGE.
;;;
;;; Note that the Lisp TYPE-OF function returns the size as well as
;;; the element type for an array. This means that if you compare
;;; types you are also comparing image sizes.
(let ((a (make-image 200 300 3 8))
(b (make-image 200 300 3 16))
(c (make-image 200 301 3 8))
(d (make-image 200 300 3 8)))
(format t "~&TYPE-OF A: ~s~%" (type-of a))
(format t " A equals B: ~a~%" (equal (type-of a) (type-of b)))
(format t " A equals C: ~a~%" (equal (type-of a) (type-of c)))
(format t " A equals D: ~a~%" (equal (type-of a) (type-of d))))
;; TYPE-OF A: (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (200 300 3))
;; A equals B: NIL
;; A equals C: NIL
;; A equals D: T
;;;# Operations on IMAGEs
;;;
;;;
;;;# Encoders and Decoders
;;;
;;;## PNG
;;;
;;; TBD
;;;
;;;### Example
;;;
(defun rotate-file (input-pathname output-pathname)
"Read a PNG image, rotate it 90 degrees CCW, and write it to a new file."
(let* ((old (with-open-file (input input-pathname :element-type '(unsigned-byte 8))
(decode input)))
(new (rotate old)))
(with-open-file (output output-pathname :element-type '(unsigned-byte 8)
:direction :output :if-exists :supersede)
(encode new output))))
;;;## BMP
;;;
;;; TBD
;;;
;;;### Example
;;;
;;; TBD
;;;## TIF, JPEG, and other formats
;;;
;;; Planned but not implemented yet.
;;;
| 1,899 | Common Lisp | .lisp | 62 | 27.854839 | 85 | 0.624315 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c46e8ff6ba3b1bc314ef042f421b607d8c84d506e68f00517358793d707e33e2 | 7,723 | [
-1
] |
7,724 | png.asd | ljosa_cl-png/png.asd | ;;;; -*- Mode: Lisp; -*-
(in-package #:cl-user)
(asdf:defsystem #:png
:description "Read and write PNG (Portable Network Graphics) files."
:perform (asdf:load-op :after (op png)
(pushnew :png *features*))
:components ((:file "png-package" :depends-on ("image"))
(:file "compat" :depends-on ("png-package"))
(:file "libpng" :depends-on ("grovel" "compat" "png-package" "wrappers"))
(:cffi-grovel-file "grovel")
(:cffi-wrapper-file "wrappers")
(:file "image")
(:file "bmp" :depends-on ("image"))
(:file "pnm" :depends-on ("image"))
(:file "ops" :depends-on ("image")))
:depends-on (#:cffi)
:defsystem-depends-on ("cffi-grovel"))
| 763 | Common Lisp | .asd | 17 | 35.882353 | 81 | 0.551075 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 6a56dcc67c50d4b76483f6e649b5938aa18a3a88d0c65a11f9d170c4864841c5 | 7,724 | [
-1
] |
7,725 | bmp-test.asd | ljosa_cl-png/test/bmp-test.asd | ;;;; -*- Mode: Lisp; -*-
(asdf:defsystem :bmp-test
:components ((:file "bmp-test" :depends-on ("lisp-unit"))
(:file "lisp-unit")
)
:depends-on (#:png))
| 173 | Common Lisp | .asd | 6 | 24.333333 | 59 | 0.542169 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 40c74f4e813b5efa3931b0270cbb7b06630f23b0ddb876e8e3c91765b1f1a3f4 | 7,725 | [
-1
] |
7,726 | png-test.asd | ljosa_cl-png/test/png-test.asd | ;;;; -*- Mode: Lisp; -*-
(asdf:defsystem :png-test
:components ((:file "png-test" :depends-on ("lisp-unit"))
(:file "lisp-unit")
)
:depends-on (#:png)) | 172 | Common Lisp | .asd | 6 | 24.333333 | 59 | 0.542169 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 805f6f3dfb10b9467bf2a13027c3aa72effd58b13716891fbbfe635f2e18dd96 | 7,726 | [
-1
] |
7,727 | ops-test.asd | ljosa_cl-png/test/ops-test.asd | ;;;; -*- Mode: Lisp; -*-
(asdf:defsystem :ops-test
:components ((:file "ops-test" :depends-on ("lisp-unit"))
(:file "lisp-unit")
)
:depends-on (#:png))
| 174 | Common Lisp | .asd | 6 | 24.333333 | 59 | 0.542169 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 839427e4391e18e86d0fff11f20f0567738fcb0432c4f933bd147df1bf6fcf24 | 7,727 | [
-1
] |
7,728 | image-test.asd | ljosa_cl-png/test/image-test.asd | ;;;; -*- Mode: Lisp; -*-
(asdf:defsystem #:image-test
:components ((:file "image-test" :depends-on ("lisp-unit"))
(:file "lisp-unit")
)
:depends-on (#:png))
| 178 | Common Lisp | .asd | 6 | 25.166667 | 61 | 0.549708 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | ef363fc3c916967ca2d0414612f65fa36e29dd6abe134756e72e76ebac986549 | 7,728 | [
-1
] |
7,745 | changelog | ljosa_cl-png/debian/changelog | cl-png (0.2.1-1) unstable; urgency=low
* Patch from Milan Zamazal (closes:20600)
-- Kevin M. Rosenberg <[email protected]> Mon, 18 Aug 2003 01:22:23 -0600
cl-png (0.2-3) unstable; urgency=low
* Remove 'load-compiled-op from .asd file
* Changes compared to upstream:
- Added .asd file for use with Common Lisp Controller
- Change package naming for compatibility with Allegro case-sensitive mode
- Change defconstants to defvars for objects that aren't EQL on reload
-- Kevin M. Rosenberg <[email protected]> Mon, 2 Dec 2002 11:37:39 -0700
cl-png (0.2-2) unstable; urgency=low
* Fix description
-- Kevin M. Rosenberg <[email protected]> Tue, 5 Nov 2002 21:37:42 -0700
cl-png (0.2-1) unstable; urgency=low
* Initial release (closes: 167961)
-- Kevin M. Rosenberg <[email protected]> Tue, 22 Oct 2002 09:57:38 -0600
| 850 | Common Lisp | .l | 16 | 49.4375 | 79 | 0.715674 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | ad8114763bf688135ec30b3ddb47b80ddaa030fbeb6ee7bfe97b6c3c9b63f116 | 7,745 | [
-1
] |
7,746 | rules | ljosa_cl-png/debian/rules | #!/usr/bin/make -f
pkg := png
debpkg := cl-png
clc-source := usr/share/common-lisp/source
clc-systems := usr/share/common-lisp/systems
clc-png := $(clc-source)/$(pkg)
doc-dir := usr/share/doc/$(debpkg)
configure: configure-stamp
configure-stamp:
dh_testdir
# Add here commands to configure the package.
touch configure-stamp
build: build-stamp
build-stamp: configure-stamp
dh_testdir
# Add here commands to compile the package.
touch build-stamp
clean:
dh_testdir
dh_testroot
rm -f build-stamp configure-stamp
# Add here commands to clean up after the build process.
rm -f debian/cl-png.postinst.* debian/cl-png.prerm.*
dh_clean
install: build
dh_testdir
dh_testroot
dh_clean -k
# Add here commands to install the package into debian/png.
dh_installdirs $(clc-systems) $(clc-png)
dh_install png.asd $(shell echo *.cl) $(clc-png)
dh_link $(clc-png)/png.asd $(clc-systems)/png.asd
# Build architecture-independent files here.
binary-indep: build install
# Build architecture-dependent files here.
binary-arch: build install
dh_testdir
dh_testroot
dh_installdocs
dh_installchangelogs
dh_strip
dh_compress
dh_fixperms
dh_installdeb
dh_shlibdeps
dh_gencontrol
dh_md5sums
dh_builddeb
binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary install configure
| 1,332 | Common Lisp | .l | 50 | 24.66 | 69 | 0.782609 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 9b66a5c2c0477b611a6166ed91fe744146f67ca4183b3f5873cca5c5e54d505e | 7,746 | [
-1
] |
7,747 | control | ljosa_cl-png/debian/control | Source: cl-png
Section: devel
Priority: optional
Maintainer: Kevin M. Rosenberg <[email protected]>
Build-Depends-Indep: debhelper (>= 4.0.0)
Standards-Version: 3.6.0
Package: cl-png
Architecture: all
Depends: ${shlibs:Depends}, common-lisp-controller (>= 3.47)
Description: Common Lisp package to read and write PNG image files
This package includes functions for reading and writing PNG image files as
well as functions for compressing and decompressing zipped files.
| 472 | Common Lisp | .l | 12 | 37.916667 | 75 | 0.805252 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 7f0f6752b2afc1e5727bf2e85c7c13d5359e242f2ae95eead2f85dfd05f671c6 | 7,747 | [
-1
] |
7,748 | config.yml | ljosa_cl-png/.circleci/config.yml | version: 2
jobs:
build:
docker:
- image: debian:stable
working_directory: /src/cl-png
steps:
- run: apt-get update -y && apt-get install -y sbcl wget gcc libpng-dev git ssh
- checkout
- run: wget https://beta.quicklisp.org/quicklisp.lisp
- run: sbcl --load quicklisp.lisp --eval "(quicklisp-quickstart:install)" --eval '(ql:quickload "cffi")' --quit
- run: ln -s /src/cl-png /root/quicklisp/local-projects/png
- run: sbcl --disable-debugger --load /root/quicklisp/setup.lisp --eval '(ql:quickload "png")' --eval "(asdf:oos 'asdf:load-op '#:png-test)" --eval "(lisp-unit:run-all-tests :png-test)" --quit
- run: sbcl --disable-debugger --load /root/quicklisp/setup.lisp --eval '(ql:quickload "png")' --eval "(asdf:oos 'asdf:load-op '#:image-test)" --eval "(lisp-unit:run-all-tests :image-test)" --quit
- run: sbcl --disable-debugger --load /root/quicklisp/setup.lisp --eval '(ql:quickload "png")' --eval "(asdf:oos 'asdf:load-op '#:bmp-test)" --eval "(lisp-unit:run-all-tests :bmp-test)" --quit
- run: sbcl --disable-debugger --load /root/quicklisp/setup.lisp --eval '(ql:quickload "png")' --eval "(asdf:oos 'asdf:load-op '#:ops-test)" --eval "(lisp-unit:run-all-tests :ops-test)" --quit
| 1,270 | Common Lisp | .l | 16 | 73.125 | 202 | 0.651125 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | d4fbb4b21605ab320f209b29352f4e12d7babbb4bbda8df053eb2eb7ad4d026e | 7,748 | [
-1
] |
7,750 | index.html | ljosa_cl-png/doc/index.html | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<HTML>
<HEAD>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<TITLE>CL-PNG</TITLE>
<style type="text/css">
body { }
hr {
color: #000;
background-color: #000;
height: 1px;
}
div.narrow { max-width: 80ex; }
table.paste-area tr td { min-width: 80ex; }
body { background: white; color: black; }
.paste { background-color: #F4F4F4; color: black; }
.paste:hover { background-color: #F4F4F4; color: black; }
.symbol { color : #770055; background-color : transparent; border: 0px; margin: 0px;}
a.symbol:link { color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
a.symbol:active { color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
a.symbol:visited { color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
a.symbol:hover { color : #229955; background-color : transparent; text-decoration: none; border: 0px; margin: 0px; }
.special { color : #FF5000; background-color : inherit; }
.keyword { color : #770000; background-color : inherit; }
.comment { color : #007777; background-color : inherit; }
.string { color : #777777; background-color : inherit; }
.atom { color : #314F4F; background-color : inherit; }
.macro { color : #FF5000; background-color : inherit; }
.variable { color : #36648B; background-color : inherit; }
.function { color : #8B4789; background-color : inherit; }
.attribute { color : #FF5000; background-color : inherit; }
.character { color : #0055AA; background-color : inherit; }
.syntaxerror { color : #FF0000; background-color : inherit; }
span.paren1 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren1:hover { color : inherit; background-color : #BAFFFF; }
span.paren2 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren2:hover { color : inherit; background-color : #FFCACA; }
span.paren3 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren3:hover { color : inherit; background-color : #FFFFBA; }
span.paren4 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren4:hover { color : inherit; background-color : #CACAFF; }
span.paren5 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren5:hover { color : inherit; background-color : #CAFFCA; }
span.paren6 { background-color : inherit; -webkit-transition: background-color 0.2s linear; }
span.paren6:hover { color : inherit; background-color : #FFBAFF; }
td.example {
background-color: #F4F4F4;
width: 100%;
}
</style>
</HEAD>
<BODY>
<div class="narrow">
<a href="https://github.com/ljosa/cl-png/"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub"></a>
<P><a href="http://www.ljosa.com/~ljosa/">Vebjorn Ljosa</a> »
<a href="http://www.ljosa.com/~ljosa/software/">Software</a> » CL-PNG
<h1>CL-PNG</h1>
<p>CL-PNG is a Common Lisp library for reading and writing PNG
(Portable Network Graphics) files. It is currently maintained
by <a href="http://www.ljosa.com/~ljosa/contact">Vebjorn Ljosa</a>,
and new versions can be found at the CL-PNG
homepage, <A href="http://www.ljosa.com/~ljosa/software/cl-png/">http://www.ljosa.com/~ljosa/software/cl-png/</a>.
<p>Copyright © 2001–2010 by the authors (see the file <A
href="https://raw.github.com/ljosa/cl-png/master/AUTHORS">AUTHORS</A>). Licensed under the GNU
Lesser General Public License; see the file <A
href="https://raw.github.com/ljosa/cl-png/master/COPYING">COPYING</A> for
details. This manual is in the public domain.
<p>Table of contents:
<ol>
<li><a href="#Status">Status</a>
<li><a href="#Download">Download</a>
<li><a href="#Installation">Installation</a>
<li><a href="#Example">Example</a>
<li><a href="#API">API reference</a>
<li><a href="#Index">Symbol index</a>
</ol>
<h2><a name="Status">Status</a></h2>
<p>CL-PNG 0.6 has been verified to work on the following platforms.
<ul>
<li>SBCL on Linux (x86_64), Mac OS X (i386 and x86_64), and Windows (i386)
<li>Clozure CL on Mac OS X (ppc and x86_64)
<li>CLISP on Linux (x86_64)
<li>Allegro CL on Mac OS X (i386 and ppc)
<li>LispWorks on Mac OS X (i386)
</ul>
<p>Please <a href="http://www.ljosa.com/~ljosa/contact">report</a> success/failure on other platforms.
<p>Since version 0.5, CL-PNG uses a foreign function interface to call
<a href="http://www.libpng.org/pub/png/libpng.html">libpng</a>, the
official PNG reference library. As a result, it benefits from all the
effort that has been put into that library: CL-PNG is much faster than
before, and better able to handle corner cases.
<p>The interface is likely to change in future versions. Please <a
href="http://www.ljosa.com/~ljosa/contact">report</a> on your
experience with the current interface.
<p>The current version has the following limitation:
<ul>
<li>Alpha channels and metadata (such as timestamps and comments)
cannot be included when writing an image. They are silently
ignored when reading an image.
</ul>
<p>News in version 0.6:</p>
<ul>
<li>Can now read from and write to Lisp streams, even those without
file descriptors
<li>Fixed bug causing crash on 64-bit platforms
<li>Can now read, write, and represent 16-bit images. (Previously
downscaled to 8 bits on read.)
<li>Fixed bug in reading of 1, 2, and 4-bit images on CCL DarwinPPC.
</ul>
<h2><a name="Download">Download</a></h2>
<ul>
<li>The easiest way to download and install CL-PNG is using QuickLisp: <tt>(ql:quickload "png")</tt>
<li>Version 0.6: <A
href="http://www.ljosa.com/~ljosa/software/cl-png/download/cl-png-0.6.tar.gz">cl-png-0.6.tar.gz</A>
<li><A href="http://www.ljosa.com/~ljosa/software/cl-png/download/">Tarballs
of older versions</A>
<li><a href="https://github.com/ljosa/cl-png/tree/REL_0_6">Browse source code for version 0.6</a> on GitHub
<li><a href="https://github.com/ljosa/cl-png">GitHub repository</a>
</ul>
<h2><a name="Installation">Installation</a></h2>
<p>CL-PNG depends on <a
href="http://www.libpng.org/pub/png/libpng.html">libpng</a> (your
operating system distribution may have a separate package, called
<tt>libpng-dev</tt> or something similar, that contains the required
<tt>png.h</tt> header file) and <a
href="http://common-lisp.net/project/cffi/">CFFI</a>. CFFI in turn
depends on <a
href="http://common-lisp.net/project/alexandria/">Alexandria</a>, <a
href="http://common-lisp.net/project/babel/">Babel</a>, and <a
href="http://www.cliki.net/trivial-features">trivial-features</a>.
<p>The easiest way to download and install CL-PNG and the Lisp
libraries that it depends on is
using <a href="http://www.quicklisp.org/">QuickLisp</a>:
<pre>
(ql:quickload "png")
</pre>
<p>If you do not want to use QuickLisp, install the dependencies, then
symlink <tt>png.asd</tt> (and, if you'd like to run the unit
tests, <tt>png-test.asd</tt>) to one of the directories
in <a href="http://constantly.at/lisp/asdf/Using-asdf-to-load-systems.html#Using%20asdf%20to%20load%20systems"><b>asdf:*central-registry*</b></a>.
Then, evaluate <code>(asdf:oos 'asdf:load-op '#:png)</code> in order
to compile and load CL-PNG.</p>
<p>On Mac OS X 10.4, you may discover that the C compiler does not
accept the <code>-m32</code> option that <a
href="http://common-lisp.net/project/cffi/manual/html_node/The-Groveller.html">CFFI-Grovel</a>
attempts to pass to it. You will need to work around this, for instance
by setting <b>cffi-grovel::*cpu-word-size-flags*</b> to the empty
string.
<p>If you would like to run the unit tests, evaluate <code>(asdf:oos
'asdf:load-op '#:png-test)</code> followed by
<code>(lisp-unit:run-all-tests #:png-test)</code>.
<h2><a name="Example">Example</a></h2>
</div>
<table class="paste-area"><tr><td class="example"><tt><span class="paste"><span class="paren1">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_defun.htm" class="symbol"><i><span class="symbol">defun</span></i></a> rotate <span class="paren2">(<span class="paste">input-pathname output-pathname</span>)</span><br> <span class="string">"Read a PNG image, rotate it 90 degrees, and write it to a new file."</span><br> <span class="paren2">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/s_let_l.htm" class="symbol"><i><span class="symbol">let*</span></i></a> <span class="paren3">(<span class="paste"><span class="paren4">(<span class="paste">old <span class="paren5">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_w_open.htm" class="symbol"><i><span class="symbol">with-open-file</span></i></a> <span class="paren6">(<span class="paste">input input-pathname <br> <span class="keyword">:element-type</span> '<span class="paren1">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/t_unsgn_.htm" class="symbol">unsigned-byte</a> 8</span>)</span></span>)</span><br> <span class="paren6">(<span class="paste"><a href="#decode" class="symbol">png:decode</a> input</span>)</span></span>)</span></span>)</span><br> <span class="paren4">(<span class="paste">new <span class="paren5">(<span class="paste"><a href="#make-image" class="symbol">png:make-image</a> <span class="paren6">(<span class="paste"><a href="#image-width" class="symbol">png:image-width</a> old</span>)</span><br> <span class="paren6">(<span class="paste"><a href="#image-height" class="symbol">png:image-height</a> old</span>)</span><br> <span class="paren6">(<span class="paste"><a href="#image-channels" class="symbol">png:image-channels</a> old</span>)</span><br> <span class="paren6">(<span class="paste"><a href="#image-bit-depth" class="symbol">png:image-bit-depth</a> old</span>)</span></span>)</span></span>)</span><br> <span class="paren4">(<span class="paste">m <span class="paren5">(<span class="paste"><a href="#image-width" class="symbol">png:image-width</a> old</span>)</span></span>)</span></span>)</span><br> <span class="paren3">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_dotime.htm" class="symbol">dotimes</a> <span class="paren4">(<span class="paste">i <span class="paren5">(<span class="paste"><a href="#image-height" class="symbol">png:image-height</a> new</span>)</span></span>)</span><br> <span class="paren4">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_dotime.htm" class="symbol">dotimes</a> <span class="paren5">(<span class="paste">j <span class="paren6">(<span class="paste"><a href="#image-width" class="symbol">png:image-width</a> new</span>)</span></span>)</span><br> <span class="paren5">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_dotime.htm" class="symbol">dotimes</a> <span class="paren6">(<span class="paste">k <span class="paren1">(<span class="paste"><a href="#image-channels" class="symbol">png:image-channels</a> new</span>)</span></span>)</span><br> <span class="paren6">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/a_setf.htm" class="symbol">setf</a> <span class="paren1">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/f_aref.htm" class="symbol">aref</a> new i j k</span>)</span> <span class="paren1">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/f_aref.htm" class="symbol">aref</a> old j <span class="paren2">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/a__.htm" class="symbol">-</a> m i 1</span>)</span> k</span>)</span></span>)</span></span>)</span></span>)</span></span>)</span><br> <span class="paren3">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/m_w_open.htm" class="symbol"><i><span class="symbol">with-open-file</span></i></a> <span class="paren4">(<span class="paste">output output-pathname <span class="keyword">:element-type</span> '<span class="paren5">(<span class="paste"><a href="http://www.lispworks.com/reference/HyperSpec/Body/t_unsgn_.htm" class="symbol">unsigned-byte</a> 8</span>)</span><br> <span class="keyword">:direction</span> <span class="keyword">:output</span> <span class="keyword">:if-exists</span> <span class="keyword">:supersede</span></span>)</span><br> <span class="paren4">(<span class="paste"><a href="#encode" class="symbol">png:encode</a> new output</span>)</span></span>)</span></span>)</span></span>)</span></span></tt></td></tr></table>
<div class="narrow">
<h2><a name="API">API reference</a></h2>
<p><a name="image"><i>Type</i> <b>IMAGE</b></a>
<p><b>Supertypes:</b><p><a
href="http://www.lispworks.com/documentation/HyperSpec/Body/t_array.htm"><b>array</b></a>,
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_t.htm"><b>t</b></a>
<p><b>Description:</b> <p>An image is a three-dimensional array of
<tt>(unsigned-byte 8)</tt> or <tt>(unsigned-byte 16)</tt>. The three
dimensions represent row, column, and <a
href="http://en.wikipedia.org/wiki/Channel_(digital_image)">channel</a>.
In other words, <tt>(aref image i j k)</tt> is the intensity in the
<tt>k</tt>-th channel of the pixel in the <tt>i</tt>-th row and
<tt>j</tt>-th column of <tt>image</tt>.</p>
<p>In the current version, an image is displaced to a one-dimensional
<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/t_smp_ar.htm"><b>simple-array</b></a>
with the same total number of elements, but applications should not
rely on this implementation detail, as it is likely to change in
future versions. Also, the <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/t_smp_ar.htm"><b>simple-array</b></a>
must be allocated in the a static area on some Lisp implementations.
For these reasons, you should use <a
href="#make-image"><b>make-image</b></a> to make your images rather
than call <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/f_mk_ar.htm"><b>make-array</b></a>
directly.
<p><b>Compound Type Specifier Kind:</b>
<p>Specializing.
<p><b>Compound Type Specifier Syntax:</b>
<p><b>image</b> <i>[{ height
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { width
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { channels
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
}]</i>
<p><b>Compound Type Specifier Arguments:</b>
<p><i>height, width, channels</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<hr>
<p><a name="8-bit-image"><i>Type</i> <b>8-BIT-IMAGE</b></a>
<p><b>Supertypes:</b><p><a href="#image"><b>image</b></a>, <a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_array.htm"><b>array</b></a>,
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_t.htm"><b>t</b></a>
<p><b>Description:</b>
<p>An <a href="#image"><b>image</b></a> with <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_a.htm#array_element_type">element type</a>
<code>(unsigned-byte 8)</code>.</p>
<p><b>Compound Type Specifier Kind:</b>
<p>Specializing.
<p><b>Compound Type Specifier Syntax:</b>
<p><b>8-bit-image</b> <i>[{ height
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { width
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { channels
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
}]</i>
<p><b>Compound Type Specifier Arguments:</b>
<p><i>height, width, channels</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<hr>
<p><a name="16-bit-image"><i>Type</i> <b>16-BIT-IMAGE</b></a>
<p><b>Supertypes:</b><p><a href="#image"><b>image</b></a>, <a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_array.htm"><b>array</b></a>,
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_t.htm"><b>t</b></a>
<p><b>Description:</b>
<p>An <a href="#image"><b>image</b></a> with <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_a.htm#array_element_type">element type</a>
<code>(unsigned-byte 16)</code>.</p>
<p><b>Compound Type Specifier Kind:</b>
<p>Specializing.
<p><b>Compound Type Specifier Syntax:</b>
<p><b>8-bit-image</b> <i>[{ height
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { width
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { channels
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
}]</i>
<p><b>Compound Type Specifier Arguments:</b>
<p><i>height, width, channels</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<hr>
<p><a name="grayscale-image"><i>Type</i> <b>GRAYSCALE-IMAGE</b></a>
<p><b>Supertypes:</b><p><a href="#image"><b>image</b></a>, <a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_array.htm"><b>array</b></a>,
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_t.htm"><b>t</b></a>
<p><b>Description:</b>
<p>An <a href="#image"><b>image</b></a> with one <a href="http://en.wikipedia.org/wiki/Channel_(digital_image)">channel</a>.</p>
<p><b>Compound Type Specifier Kind:</b>
<p>Specializing.
<p><b>Compound Type Specifier Syntax:</b>
<p><b>grayscale-image</b> <i>[{ height
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { width
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
}]</i>
<p><b>Compound Type Specifier Arguments:</b>
<p><i>height, width</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<p><b>Notes:</b>
<p><tt>(grayscale-image n m) == (image n m 1)</tt>
<hr>
<p><a name="rgb-image"><i>Type</i> <b>RGB-IMAGE</b></a>
<p><b>Supertypes:</b><p><a href="#image"><b>image</b></a>, <a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_array.htm"><b>array</b></a>,
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/t_t.htm"><b>t</b></a>
<p><b>Description:</b>
<p>An <a href="#image"><b>image</b></a> with three <a href="http://en.wikipedia.org/wiki/Channel_(digital_image)">channels</a>.</p>
<p><b>Compound Type Specifier Kind:</b>
<p>Specializing.
<p><b>Compound Type Specifier Syntax:</b>
<p><b>rgb-image</b> <i>[{ height
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
} { width
| <a href="http://www.lispworks.com/documentation/HyperSpec/Body/a_st.htm#ST">*</a>
}]</i>
<p><b>Compound Type Specifier Arguments:</b>
<p><i>height, width</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<p><b>Notes:</b>
<p><tt>(rgb-image n m) == (image n m 3)</tt>
<hr>
<p><a name="make-image"><i>Function</i> <b>MAKE-IMAGE</b></a>
<p><b>Syntax:</b>
<p><b>make-image</b> <i>height width channels <tt>&optional</tt> bit-depth</i> => <i>image</i>
<p><b>Arguments and Values:</b>
<p><i>height, width, channels</i>---<a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimensions</a>
<p><i>bit-depth</i>---either 8, or 16, or <b>nil</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><b>Description:</b> <p>Makes a new <a
href="#image"><b>image</b></a> with the specified height, width, and
number of <a
href="http://en.wikipedia.org/wiki/Channel_(digital_image)">channels</a>.
The image will be an <a href="#8-bit-image"><b>8-bit-image</b></a> if
<i>bit-depth</i> is 8 or <b>nil</b>, and a <a
href="#16-bit-image"><b>16-bit-image</b></a> if <i>bit-depth</i> is
16. The contents of the image are undefined.
<hr>
<p><a name="image-height"><i>Function</i> <b>IMAGE-HEIGHT</b></a>
<p><b>Syntax:</b>
<p><b>image-height</b> <i>image</i> => <i>height</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>height</i>---a <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimension</a>
<p><b>Description:</b>
<p>Returns the height of <i>image</i>, i.e., the number of rows.</p>
<hr>
<p><a name="image-width"><i>Function</i> <b>IMAGE-WIDTH</b></a>
<p><b>Syntax:</b>
<p><b>image-width</b> <i>image</i> => <i>width</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>width</i>---a <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimension</a>
<p><b>Description:</b>
<p>Returns the width of <i>image</i>, i.e., the number of columns.</p>
<hr>
<p><a name="image-channels"><i>Function</i> <b>IMAGE-CHANNELS</b></a>
<p><b>Syntax:</b>
<p><b>image-channels</b> <i>image</i> => <i>channels</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>channels</i>---a <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_v.htm#valid_array_dimension">valid
array dimension</a>
<p><b>Description:</b>
<p>Returns the number
of <a href="http://en.wikipedia.org/wiki/Channel_(digital_image)">channels</a>
in <i>image</i>. Grayscale images have one channel, whereas RGB
images have three.</p>
<hr>
<p><a name="image-bit-depth"><i>Function</i> <b>IMAGE-BIT-DEPTH</b></a>
<p><b>Syntax:</b>
<p><b>image-bit-depth</b> <i>image</i> => <i>bit-depth</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>bit-depth</i>---either 8 or 16
<p><b>Description:</b> <p>Returns the bit-depth of the image, i.e.,
the number of bits in the byte representing each sample. The bit
depth of an <a href="#8-bit-image"><b>8-bit-image</b></a> is 8, and
the bit-depth of a <a href="#16-bit-image"><b>16-bit-image</b></a> is
16.</p>
<hr>
<p><a name="copy-image"><i>Function</i> <b>COPY-IMAGE</b></a>
<p><b>Syntax:</b>
<p><b>copy-image</b> <i>image</i> => <i>copied-image</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>copied-image</i>---an <a href="#image"><b>image</b></a>
<p><b>Description:</b> <p>Creates a copy of <i>image</i>. The
elements of the new image are the <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_s.htm#same">same</a>
as the corresponding elements of <i>image</i>, and <i>copied-image</i>
has the same height, width, number of channels, and bit depth as
<i>image</i>.</p>
<hr>
<p><a name="f_8-bit-image"><i>Function</i> <b>8-BIT-IMAGE</b></a>
<p><b>Syntax:</b>
<p><b>8-bit-image</b> <i>image</i> => <i>result-image</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>result-image</i>---an <a href="#image"><b>image</b></a>
<p><b>Description:</b> <p>If <i>image</i> is an <a
href="#8-bit-image"><b>8-bit-image</b></a>, return it or a copy of it.
If <i>image</i> is a <a href="#16-bit-image"><b>16-bit-image</b></a>,
return an <a href="#8-bit-image"><b>8-bit-image</b></a> that has the
same width, height, and number of channels as <i>image</i>, but where
each element is the corresponding element in <i>image</i> divided by
257 and rounded to the nearest integer. The effect of this division
is to compress the dynamic range of the image so as to fit within the
smaller bit depth.</p>
<hr>
<p><a name="f_16-bit-image"><i>Function</i> <b>16-BIT-IMAGE</b></a>
<p><b>Syntax:</b>
<p><b>16-bit-image</b> <i>image</i> => <i>result-image</i>
<p><b>Arguments and Values:</b>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><i>result-image</i>---an <a href="#image"><b>image</b></a>
<p><b>Description:</b> <p>If <i>image</i> is a <a
href="#16-bit-image"><b>16-bit-image</b></a>, return it or a copy of
it. If <i>image</i> is an <a
href="#8-bit-image"><b>8-bit-image</b></a>, return a <a
href="#16-bit-image"><b>16-bit-image</b></a> that has the same width,
height, and number of channels as <i>image</i>, but where each element
is the corresponding element in <i>image</i> multiplied by 257. The
effect of this multiplication is to stretch the dynamic range of the
image to utilize the increased bit depth.</p>
<hr>
<p><a name="decode"><i>Function</i> <b>DECODE</b></a>
<p><b>Syntax:</b>
<p><b>decode</b> <i>input</i> => <i>image</i>
<p><b>Arguments and Values:</b>
<p><i>input</i>---an fd <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_i.htm#input">input</a>
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_s.htm#stream">stream</a></p>
<p><i>image</i>---an <a href="#image"><b>image</b></a>
<p><b>Description:</b> <p>Reads an image in PNG format from
<i>input</i> and returns an array of type <a
href="#image"><b>image</b></a>. If the bit depth of the PNG file is
less than or equal to 8, an <a
href="#8-bit-image"><b>8-bit-image</b></a> will be returned;
otherwise, a <a href="#16-bit-image"><b>16-bit-image</b></a> will be
returned.
<p>Applications that would like to receive images of consistent bit
depth (rather than 8 or 16 depending on the PNG file) can apply the
function <a href="#f_8-bit-image"><b>8-bit-image</b></a> or the
function <a href="#f_16-bit-image"><b>16-bit-image</b></a> to the
result of <b>decode</b>.
<p>An image with bit depths below 8 will be converted to 8 bits when
read, and an image with bit depths between 8 and 16 bits will be
converted to 16 bits. As an example, a 2-bit PNG file contains only the
pixel values 0, 1, 2, and 3. These will be converted to 0, 85, 170,
and 255, respectively, in order to fill the dynamic range of the 8-bit
image that is returned.
<p><b>Exceptional Situations:</b>
<p>Signals
an <a href="http://www.lispworks.com/documentation/HyperSpec/Body/e_error.htm#error"><b>error</b></a>
if reading the image fails.</p>
<hr>
<p><a name="encode"><i>Function</i> <b>ENCODE</b></a>
<p><b>Syntax:</b>
<p><b>encode</b> <i>image</i> <i>output</i> => <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/a_t.htm"><b><i>t</i></b></a>
<p><b>Arguments and Values:</b>
<p><i>image</i>---a <a href="#grayscale-image"><i>grayscale-image</i></a> or <a href="#rgb-image"><i>rgb-image</i></a>
<p><i>output</i>---an fd <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_o.htm#output">output</a>
<a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_s.htm#stream">stream</a></p>
<p><b>Description:</b> <p>Writes <i>image</i> in PNG format to
<i>output</i>. The current version always writes an 8-bit PNG file if
<i>image</i> is an <a href="#8-bit-image"><b>8-bit-image</b></a> and a
16-bit PNG file if <i>image</i> is an <a
href="#16-bit-image"><b>16-bit-image</b></a>. Future versions may
write PNG files of lower bit depths than <i>image</i> when the least
significant bits may be trimmed without loss of precision.
<p><b>Exceptional Situations:</b> <p>Signals an <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/e_error.htm#error"><b>error</b></a>
if writing the image fails.
</p>
<hr>
<h2><a name="Index">SYMBOL INDEX:</a></h2>
<ul>
<li><a href="#8-bit-image"><b>8-bit-image</b></a> (type)
<li><a href="#f_8-bit-image"><b>8-bit-image</b></a> (function)
<li><a href="#16-bit-image"><b>16-bit-image</b></a> (type)
<li><a href="#f_16-bit-image"><b>16-bit-image</b></a> (function)
<li><a href="#copy-image"><b>copy-image</b></a>
<li><a href="#decode"><b>decode</b></a>
<li><a href="#encode"><b>encode</b></a>
<li><a href="#grayscale-image"><b>grayscale-image</b></a>
<li><a href="#image"><b>image</b></a>
<li><a href="#image-bit-depth"><b>image-bit-depth</b></a>
<li><a href="#image-channels"><b>image-channels</b></a>
<li><a href="#image-height"><b>image-height</b></a>
<li><a href="#image-width"><b>image-width</b></a>
<li><a href="#make-image"><b>make-image</b></a>
<li><a href="#rgb-image"><b>rgb-image</b></a>
</ul>
<hr>
<p>Last updated: 2013-07-24</p>
</div>
</BODY>
</HTML>
| 29,843 | Common Lisp | .l | 465 | 62.410753 | 6,106 | 0.68722 | ljosa/cl-png | 19 | 10 | 4 | LGPL-2.1 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | b3465704ca5109722e6f8822db8aa1d0a497e3b87c2fc8c67c6eef6da48acc1c | 7,750 | [
-1
] |
7,765 | data-form.lisp | VitoVan_cl-spider/data-form.lisp | (in-package :cl-spider)
(defclass form()
((action :accessor form-action :initarg :action)
(method :accessor form-method :initarg :method)
(fields :accessor form-fields :initarg :fields)
(cookie :accessor form-cookie :initarg :cookie)))
(defun assoc-string (string alist)
(cdr (assoc string alist :test #'equal)))
(defun get-form (uri &key (selector "form") parameters)
(let* ((cookie-jar (make-instance 'cookie-jar))
(html-raw (get-html uri :cookie-jar cookie-jar))
(form-raw (car (html-block-select
nil
:params parameters
:selector selector
:desires '(((:selector . "input") (:attrs . ("name" "value")))
((:selector . "form") (:attrs . ("action" "method"))))
:html html-raw)))
(form-fields)
(form-action)
(form-method :get))
(dolist (f form-raw)
(let* ((f-value (assoc-string "value" f))
(f-name (assoc-string "name" f))
(f-action (assoc-string "action" f))
(f-method (assoc-string "method" f)))
(if f-name
(push (cons f-name f-value) form-fields)
(progn
(setf form-action f-action)
(setf form-method f-method)))))
(make-instance 'form
:action form-action
:method form-method
:fields form-fields
:cookie cookie-jar)))
(defun update-form (key value form-obj)
(let* ((fields (form-fields form-obj))
(field (assoc key fields :test #'equal)))
(if field
(rplacd
field
value)
(setf
(form-fields form-obj)
(push (cons key value) fields)))))
(defun exec-form (form-obj &key base-url)
(http-request
(concatenate 'string base-url (form-action form-obj))
:method (if (equal (form-method form-obj) "post") :post :get)
:user-agent *cl-spider-user-agent*
:parameters (form-fields form-obj)
:cookie-jar (form-cookie form-obj)))
| 2,114 | Common Lisp | .lisp | 53 | 29.471698 | 90 | 0.550584 | VitoVan/cl-spider | 13 | 6 | 0 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c039994a7e54f6dc490a9392a9f5a8aab16d6c9b1a147984446bdc7bc1d9e38e | 7,765 | [
-1
] |
7,766 | package.lisp | VitoVan_cl-spider/package.lisp | (in-package #:cl-user)
(defpackage #:cl-spider
(:use #:common-lisp #:drakma #:plump #:clss)
(:export
#:html-select
#:html-block-select
#:*cl-spider-user-agent*
#:*cl-spider-max-length*
#:*cl-spider-timeout-seconds*))
| 237 | Common Lisp | .lisp | 9 | 23.111111 | 46 | 0.651982 | VitoVan/cl-spider | 13 | 6 | 0 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 995c7ee50b2746a39a0fa2e0ff7ee1bc076cc17d9730d4db4620f927b43cbf3c | 7,766 | [
-1
] |
7,767 | html-select.lisp | VitoVan_cl-spider/html-select.lisp | (in-package :cl-spider)
(defun get-html (uri &key (expected-code 200) (method :get) parameters cookie-jar)
"Get HTML strings from specific uri"
(let* ((response (multiple-value-list
(handler-case (drakma:http-request uri
:method method
:parameters parameters
:connection-timeout *cl-spider-timeout-seconds*
:user-agent *cl-spider-user-agent*
:want-stream t
:cookie-jar cookie-jar)
(error
(condition)
(format nil "~A" condition)))))
(s (car response))
(header (nth 2 response))
(content-length
(or (drakma:header-value :content-length header)
(progn (push '(:content-length . (write-to-string *cl-spider-max-length*)) header)
(write-to-string *cl-spider-max-length*))))
(size-ok (and content-length (<= (parse-integer content-length :junk-allowed t) *cl-spider-max-length*)))
(code (nth 1 response)))
(if (and code (= code expected-code))
(if size-ok
(car (multiple-value-list (drakma::read-body s header t)))
"Too large")
(or code response))))
(defun get-dom(html)
"Parse HTML strings to DOM"
(parse html))
(defun get-nodes(selector dom)
"Get nodes from DOM, by CSS selector"
(select selector dom))
(defun get-text(node)
"Get the text content in the node"
(string-trim '(#\Space #\Tab #\Newline) (text node)))
(defun html-select (uri &key selector attrs html params)
(handler-case (if (null selector)
(or html (get-html uri :parameters params))
(map 'list
#'(lambda (node)
(if attrs
(let* ((results))
(dolist (attr attrs)
(push
(cons (or (and (cl-ppcre:scan " as " attr) (cadr (cl-ppcre:split " as " attr))) attr)
(if (cl-ppcre:scan "^text$|^text as " attr)
(get-text node)
(attribute node
(or (and (cl-ppcre:scan " as " attr) (car (cl-ppcre:split " as " attr))) attr)))) results))
results)
(serialize node nil)))
(get-nodes selector (get-dom (or html (get-html uri :parameters params))))))
(error
(condition)
(format nil "~A" condition))))
;;(cl-spider:html-select "https://news.ycombinator.com/"
;; :selector "a"
;; :attrs '("href" "text"))
(defun html-block-select (uri &key selector desires params html)
(let* ((parent-html-list (html-select uri :selector selector :params params :html html)))
(mapcar
#'(lambda (parent-html)
(let* ((result))
(dolist (desire desires)
(setf result (append result
(html-select nil
:params params
:selector (cdr (assoc ':selector desire))
:attrs (cdr (assoc ':attrs desire))
:html parent-html))))
result))
parent-html-list)))
;;(cl-spider:html-block-select
;; "https://news.ycombinator.com/"
;; :selector "tr.athing"
;; :desires '(((:selector . "span.rank") (:attrs . ("text as rank")))
;; ((:selector . "td.title>a") (:attrs . ("href as uri" "text as title")))
;; ((:selector . "span.sitebit.comhead") (:attrs . ("text as site")))))
| 4,148 | Common Lisp | .lisp | 79 | 33.620253 | 150 | 0.45309 | VitoVan/cl-spider | 13 | 6 | 0 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 90cb9360efa213287e1c6fdc36f3e5bec39a7685eda747784b8433473931ced1 | 7,767 | [
-1
] |
7,768 | spider.lisp | VitoVan_cl-spider/spider.lisp | (in-package :cl-spider)
;; set default encode system
(setf drakma:*drakma-default-external-format* :UTF-8)
;; customization
(defvar *cl-spider-user-agent* "cl-spider")
(defvar *cl-spider-max-length* (* 1024 1024 2))
(defvar *cl-spider-timeout-seconds* 5)
| 256 | Common Lisp | .lisp | 7 | 35.428571 | 53 | 0.745968 | VitoVan/cl-spider | 13 | 6 | 0 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c48f4f603ea0a148bbaf52ac17147f3253396e8ed9c0704d80ab64eb9d6ca030 | 7,768 | [
-1
] |
7,769 | cl-spider.asd | VitoVan_cl-spider/cl-spider.asd | ;; -*- Lisp -*-
(in-package #:cl-user)
(defpackage #:cl-spider-system (:use #:cl #:asdf))
(in-package #:cl-spider-system)
(asdf:defsystem #:cl-spider
:author "Vito Van"
:serial t
:components ((:file "package")
(:file "spider")
(:file "html-select"))
:depends-on (:drakma :plump :clss))
| 327 | Common Lisp | .asd | 11 | 25 | 50 | 0.591054 | VitoVan/cl-spider | 13 | 6 | 0 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 39c5c0a23d6c7905fa6d5ff021baaefe88c7d477d356073c62e9e6fca25800e4 | 7,769 | [
-1
] |
7,791 | tests.lisp | lambdamikel_Common-Lisp-Persistency-Manager/src/tests.lisp | ;;; -*- Mode: Lisp; Syntax: Ansi-Common-Lisp; Package: PERSISTENCE; Base: 10 -*-
(in-package persistence)
;;;
;;;
;;;
(defpersistentclass test ()
((a :accessor a :initarg :a)
(b :accessor b :initarg :b)))
(defpersistentclass test2 (test)
((c :accessor c :initarg :c)))
(defun run-test ()
(setf table (let ((table (make-hash-table :test #'equal
:size 100
:rehash-size 100)))
(loop as i from 1 to 100 do
(setf (gethash (list i i i) table)
(loop as j from 1 to (+ i 10) collect
(list (* j j )
(- (* j j ))))))
table))
(setf x (make-instance 'test
:a table))
(setf y (make-instance 'test :a x
:b
(make-array '(10))))
(setf z (make-instance 'test2 :c (list x y
(make-array '(3)
:initial-contents (list x y x)))))
(setf orig (vector x y z (list x table (vector x z y) x z)))
(make-object-persistent orig "test")
(setf copy (load-persistent-object "test")))
(defpersistentstruct stest
(a)
(b))
(defpersistentstruct (stest2 (:include stest))
(c))
(defun run-stest ()
(setf table (let ((table (make-hash-table :test #'equal
:size 100
:rehash-size 100)))
(loop as i from 1 to 100 do
(setf (gethash (list i i i) table)
(loop as j from 1 to (+ i 10) collect (* j j ))))
table))
(setf x (make-stest
:a table))
(setf y (make-stest :a x
:b
(make-array '(10))))
(setf z (make-stest2 :c (list x y
(make-array '(3)
:initial-contents (list x y x)))))
(setf orig (vector x y z (list x table (vector x z y) x z)))
(make-object-persistent orig "test")
(setf copy (load-persistent-object "test")))
(defun test ()
(with-open-file (stream "pertest"
:element-type 'unsigned-byte
:direction :output :if-exists :supersede
:if-does-not-exist :create)
(write-coded-string stream "das ist ein test!")
(write-coded-integer stream 123)
(write-coded-symbol stream 'test)
(write-coded-number stream 123.345)
(write-coded-number stream 4/3)
(write-coded-list stream (list 1 2 3 4))
(make-instance 'test
:a table)
)
(with-open-file (stream "pertest"
:element-type 'unsigned-byte
:direction :input)
(list
(read-coded-string stream)
(read-coded-integer stream)
(read-coded-symbol stream)
(read-coded-number stream)
(read-coded-number stream)
(read-coded-list stream))))
(defun test ()
(make-object-persistent (list 'symbol 123 'test "abcdef" 123.3 4/3 (list 'a 1 2 'b "xyz"))
"pertest")
(load-persistent-object "pertest"))
| 3,260 | Common Lisp | .lisp | 83 | 26.53012 | 92 | 0.490022 | lambdamikel/Common-Lisp-Persistency-Manager | 16 | 3 | 0 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | c986bd5c1554a66391e6c39716a2eaf50eb8e879e66678d7acc5593aa7319655 | 7,791 | [
-1
] |
7,792 | persistence-package.lisp | lambdamikel_Common-Lisp-Persistency-Manager/src/persistence-package.lisp | ;;; -*- Mode: Lisp; Syntax: Ansi-Common-Lisp; Package: CL-USER; Base: 10 -*-
(in-package :CL-USER)
;;;
;;; Define Packages
;;;
(defpackage persistence
(:use common-lisp)
(:shadow #:defclass #:defstruct)
(:export
#:defpersistentclass
#:defpersistentstruct
#:initialize-loaded-persistent-object
#:make-object-persistent
#:load-persistent-object
#:print-persistence-manager-info
#:user-write-constructor
#:user-write-component-constructor
#:user-write-initializer
#:user-write-component-initializer
#:user-fill-object
#:user-read-component-object
#:user-create-empty-object))
| 627 | Common Lisp | .lisp | 22 | 25.045455 | 76 | 0.718333 | lambdamikel/Common-Lisp-Persistency-Manager | 16 | 3 | 0 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 0ce88740692511dc9bdbaf089478567d82638957436549edaa58239b078e8f1c | 7,792 | [
-1
] |
7,793 | persistence2.lisp | lambdamikel_Common-Lisp-Persistency-Manager/src/persistence2.lisp | ;;; -*- Mode: Lisp; Syntax: Ansi-Common-Lisp; Package: PERSISTENCE; Base: 10 -*-
(in-package persistence)
(defun print-persistence-manager-info (&optional (stream t))
(format stream ";;; The store/restore facility is based on software developed~%~
;;; by Michael Wessel.~2%"))
(cl:defstruct (big-vector (:constructor make-big-vector-internal))
n-elements
n-subarrays
(arrays nil))
(defconstant +max-n-of-array-elements+ (- array-total-size-limit 1))
(defun make-big-vector (dimension &key (initial-element nil))
(multiple-value-bind (n-subarrays-minus-1 size-of-rest-array)
(floor dimension +max-n-of-array-elements+)
(let ((big-vector (make-big-vector-internal)))
(setf (big-vector-n-subarrays big-vector) (+ n-subarrays-minus-1 1))
(setf (big-vector-n-elements big-vector) dimension)
(setf (big-vector-arrays big-vector)
(coerce (append (loop repeat n-subarrays-minus-1
collect (make-array +max-n-of-array-elements+
:initial-element initial-element))
(list (make-array size-of-rest-array)))
'vector))
big-vector)))
(declaim (inline bvref))
(defun bvref (big-array index)
(multiple-value-bind (subarray-index index-of-rest-array)
(floor index +max-n-of-array-elements+)
(svref (svref (big-vector-arrays big-array) subarray-index)
index-of-rest-array)))
(declaim (inline (setf bvref)))
(defun (setf bvref) (new-value big-array index)
(multiple-value-bind (subarray-index index-of-rest-array)
(floor index +max-n-of-array-elements+)
(setf (svref (svref (big-vector-arrays big-array) subarray-index)
index-of-rest-array)
new-value)))
;;;
;;;
;;;
(defconstant +persistence-version+ 3)
(defconstant +n-bytes-for-written-objects+ 16)
(defconstant +maximum-written-objects+
(- (expt 10 +n-bytes-for-written-objects+) 1))
;;(defconstant +vector-size+ 1000000)
(defconstant +hash-table-size+ 10000)
(defconstant +rehash-size+ 40000)
(defvar *read-objects* nil)
;; (make-array +vector-size+ :initial-element nil)
(defvar *written-objects*
(make-hash-table :test #'eql
:size +hash-table-size+
:rehash-size +rehash-size+))
;;;
;;;
;;;
(defvar *io-id-counter* 0)
(defvar *aux-counter* 0)
(defvar *ref-counter* 0)
(declaim (inline get-io-id-for create-io-id store retrieve
write-coded-string1
write-coded-string
read-coded-string
write-coded-symbol
read-coded-symbol
write-coded-integer
read-coded-integer
write-coded-number
read-coded-numer
write-coded-marker
read-coded-marker
write-coded-list
read-coded-list
read-byte*
unread-byte*))
;;;
;;;
;;;
(defun write-coded-string (stream string)
(write-coded-integer stream (length string))
(loop as char across string do
(write-byte (char-code char) stream)))
(defun write-coded-string-1 (stream string)
(loop as char across string do
(write-byte (char-code char) stream)))
(defun read-coded-string (stream)
(let* ((n (read-coded-integer stream))
(string (make-string n :initial-element #\space)))
(loop as i from 1 to n do
(setf (aref string (1- i))
(code-char (read-byte stream))))
string))
(defun write-coded-symbol (stream symbol)
(let* ((package (symbol-package symbol))
(name (symbol-name symbol))
(length (if (null package)
(+ 2 (length name))
(+ (length (package-name package)) 2 (length name)))))
(write-coded-integer stream length)
(if (null package)
(write-coded-string-1 stream "#:")
(progn
(write-coded-string-1 stream (package-name package))
(write-coded-string-1 stream "::")))
(write-coded-string-1 stream (symbol-name symbol))))
(defun read-coded-symbol (stream)
(read-from-string (read-coded-string stream)))
(defun write-coded-integer (stream num)
(unless (integerp num)
(error "You have given ~A to write-coded-integer!" num))
(let ((orig-num num)
(num (abs num)))
(loop
(multiple-value-bind (div mod)
(floor num 254)
(write-byte mod stream)
(setf num div)
(when (= 0 div)
(write-byte (if (minusp orig-num)
254 255)
stream)
(return-from write-coded-integer))))))
(defun read-coded-integer (stream)
(let ((num 0)
(index 1))
(loop
(let ((byte (read-byte* stream)))
(cond ((eq byte 'eof)
(return-from read-coded-integer 'eof))
((= byte 255)
(return-from read-coded-integer num))
((= byte 254)
(return-from read-coded-integer (- num)))
(t (incf num (* index byte))
(setf index (* index 254))))))))
(defun write-coded-number (stream num)
(write-coded-string stream (write-to-string num)))
(defun read-coded-number (stream)
(read-from-string (read-coded-string stream)))
(defun write-coded-marker (stream marker)
(write-byte marker stream))
(defun read-coded-marker (stream)
(read-byte* stream))
(defun write-coded-list (stream list)
(write-coded-string stream (format nil "~S" list)))
(defun read-coded-list (stream)
(read-from-string (read-coded-string stream)))
;;;
;;;
;;;
(defvar *last-byte-read* nil)
(defvar *unread-occured-p* nil)
(defun read-byte* (stream)
(if (and *unread-occured-p* *last-byte-read*)
(progn
(setf *unread-occured-p* nil)
*last-byte-read*)
(let ((byte (read-byte stream nil 'eof)))
(if (eq byte 'eof)
(setf *last-byte-read* nil)
(setf *last-byte-read* byte))
byte)))
(defun unread-byte* ()
(setf *unread-occured-p* t))
;;;
;;;
;;;
(defun get-io-id-for (object)
(or (gethash object *written-objects*)
(error "Can't find object ~A!" object)))
(defun create-io-id ()
(incf *io-id-counter*))
(defun store (io-id obj)
(setf *io-id-counter* (max io-id *io-id-counter*))
(setf (bvref *read-objects* io-id) obj)
obj)
(defun retrieve (io-id)
(or (bvref *read-objects* io-id)
(error "Object ~A not found! Dangling pointer!" io-id)))
(defun reset ()
(setf *io-id-counter* 0
*aux-counter* 0
*ref-counter* 0
*unread-occured-p* nil)
(clrhash *written-objects*))
(defun read-reset (n-of-objects-to-read)
(setf *io-id-counter* 0
*aux-counter* 0
*ref-counter* 0
*unread-occured-p* nil)
(setf *read-objects* (make-big-vector (+ n-of-objects-to-read 3)
:initial-element nil)))
;;;
;;;
;;;
(cl:defclass persistent-object ()
())
(defmethod write-object-constructor ((obj persistent-object) stream)
(declare (ignore stream))
nil)
(defmethod write-object-initializer ((obj persistent-object) stream)
(declare (ignore stream))
nil)
(defmethod fill-persistent-object ((obj persistent-object) stream)
(declare (ignore stream))
nil)
;;;
;;; verhindere, da"s initialize-instance fuer Subklassen aufgerufen wird!
;;;
(defmethod initialize-instance :around ((obj persistent-object)
&rest initargs
&key (dont-initialize nil))
(if (not dont-initialize)
(progn
(call-next-method)) ; normale Initialisierung
(apply #'shared-initialize obj t initargs)))
(defmethod initialize-loaded-persistent-object ((obj persistent-object))
nil)
;;;
;;;
;;;
(cl:defstruct persistent-structure)
(defmethod write-object-constructor ((obj persistent-structure) stream)
(declare (ignore stream))
nil)
(defmethod write-object-initializer ((obj persistent-structure) stream)
(declare (ignore stream))
nil)
(defmethod fill-persistent-object ((obj persistent-structure) stream)
(declare (ignore stream))
nil)
(defmethod initialize-loaded-persistent-object ((obj persistent-structure))
nil)
;;;
;;;
;;;
(defconstant +string-marker+ 10)
(defconstant +array-marker+ 20)
(defconstant +hashtable-marker+ 30)
(defconstant +cons-marker+ 40)
(defconstant +nil-marker+ 50)
(defconstant +integer-marker+ 60)
(defconstant +number-marker+ 70)
(defconstant +symbol-marker+ 80)
(defconstant +object-marker+ 90)
(defconstant +structure-marker+ 100)
(defconstant +unbound-marker+ 110)
(defconstant +section-marker+ 120)
(defconstant +user-responsibility-marker+ 130)
(defvar *secret-hashtable-size-key* (gensym "*#?@secret-"))
;;;
;;;
;;;
(defmacro with-only-once-constructed-object ((object marker stream) &body body)
`(unless (gethash ,object *written-objects*)
(let ((io-id (create-io-id)))
(setf (gethash ,object *written-objects*) io-id)
(write-coded-marker ,stream ,marker)
(write-coded-integer ,stream io-id)
,@body)))
(defmethod write-constructor :after ((object t) stream)
(declare (ignore stream))
(incf *ref-counter*))
;;;
;;;
;;;
(defmethod user-write-constructor (stream (object t))
(error "Please create a method \"USER-WRITE-CONSTRUCTOR (STREAM (OBJECT ~S))\"
and use subsequent calls to \"(USER-WRITE-COMPONENT-CONSTRUCTOR STREAM COMPONENT)\" to construct the
component objects of the object!" (type-of object)))
(defmethod user-write-component-constructor (stream (object t))
(write-constructor object stream))
;;;
;;;
;;;
(defmethod write-constructor ((object t) stream)
(with-only-once-constructed-object (object +user-responsibility-marker+ stream)
(write-coded-symbol stream (type-of object))
(user-write-constructor stream object))
(values))
(defmethod write-constructor ((object null) stream)
(declare (ignore stream))
(values))
(defmethod write-constructor ((object number) stream)
(declare (ignore stream))
(values))
(defmethod write-constructor ((object cons) stream)
(with-only-once-constructed-object (object +cons-marker+ stream)
(write-constructor (car object) stream)
(write-constructor (cdr object) stream))
(values))
(defmethod write-constructor ((object string) stream)
(with-only-once-constructed-object (object +string-marker+ stream)
(write-coded-string stream object))
(values))
(defmethod write-constructor ((object symbol) stream)
(with-only-once-constructed-object (object +symbol-marker+ stream)
(write-coded-symbol stream object))
(values))
(defmethod write-constructor ((object array) stream)
(with-only-once-constructed-object (object +array-marker+ stream)
(write-coded-list stream (array-dimensions object))
(dotimes (i (array-total-size object))
(write-constructor (row-major-aref object i) stream)))
(values))
(defmethod write-constructor ((object hash-table) stream)
(with-only-once-constructed-object (object +hashtable-marker+ stream)
(write-coded-integer stream (hash-table-count object))
(write-coded-integer stream (hash-table-size object))
(write-coded-integer stream (hash-table-rehash-size object))
(write-coded-number stream (hash-table-rehash-threshold object))
(write-coded-symbol stream (hash-table-test object))
(maphash #'(lambda (key value)
(write-constructor key stream)
(write-constructor value stream))
object))
(values))
(defmethod write-constructor ((object persistent-object) stream)
(write-constructor (type-of object) stream)
(with-only-once-constructed-object (object +object-marker+ stream)
(write-referencer (type-of object) stream)
(write-object-constructor object stream))
(values))
(defmethod write-constructor ((object persistent-structure) stream)
(write-constructor (type-of object) stream)
(with-only-once-constructed-object (object +structure-marker+ stream)
(write-referencer (type-of object) stream)
(write-object-constructor object stream))
(values))
;;;
;;;
;;;
(defmacro with-complex-object-header ((stream object) &body body)
`(progn
(write-coded-integer ,stream (get-io-id-for ,object))
,@body))
(defun write-referencer (object stream)
(typecase object
(null
(write-coded-marker stream +nil-marker+))
((or cons array hash-table string symbol persistent-object)
(write-coded-marker stream +object-marker+)
(write-coded-integer stream (get-io-id-for object)))
(persistent-structure
(write-coded-marker stream +structure-marker+)
(write-coded-integer stream (get-io-id-for object)))
(integer (write-coded-marker stream +integer-marker+)
(write-coded-integer stream object))
(number
(write-coded-marker stream +number-marker+)
(write-coded-number stream object))
(otherwise
(write-coded-marker stream +user-responsibility-marker+)
(write-coded-integer stream (get-io-id-for object)))))
;;;
;;;
;;;
(defmethod user-write-initializer (stream (object t))
(error "Please create a method \"USER-WRITE-INITIALIZER (STREAM (OBJECT ~S))\"
and use subsequent calls to \"(USER-WRITE-COMPONENT-INITIALIZER STREAM COMPONENT)\" to initialize
the component objects of the object!" (type-of object)))
(defmethod user-write-component-initializer (stream (object t))
(write-referencer object stream))
;;;
;;;
;;;
(defmethod write-initializer ((object t) stream)
(with-complex-object-header (stream object)
(user-write-initializer stream object))
(values))
(defmethod write-initializer ((object string) stream)
(values))
(defmethod write-initializer ((object symbol) stream)
(values))
(defmethod write-initializer ((object cons) stream)
(with-complex-object-header (stream object)
(write-referencer (car object) stream)
(write-referencer (cdr object) stream))
(values))
(defmethod write-initializer ((object array) stream)
(with-complex-object-header (stream object)
(dotimes (i (array-total-size object))
(write-referencer (row-major-aref object i)
stream)))
(values))
(defmethod write-initializer ((object hash-table) stream)
(with-complex-object-header (stream object)
(maphash #'(lambda (key value)
(write-referencer key stream)
(write-referencer value stream))
object))
(values))
(defmethod write-initializer ((object persistent-object) stream)
(with-complex-object-header (stream object)
(write-object-initializer object stream))
(values))
(defmethod write-initializer ((object persistent-structure) stream)
(with-complex-object-header (stream object)
(write-object-initializer object stream))
(values))
;;;
;;;
;;;
(defmethod fill-object ((object symbol) stream)
(declare (ignore stream))
object)
(defmethod fill-object ((object string) stream)
(declare (ignore stream))
object)
(defmethod fill-object ((object cons) stream)
(declare (ignore stream))
(setf (car object)
(read-value stream))
(setf (cdr object)
(read-value stream))
object)
(defmethod fill-object ((object array) stream)
(dotimes (i (array-total-size object))
(setf (row-major-aref object i)
(read-value stream)))
object)
(defmethod fill-object ((object hash-table) stream)
(dotimes (i (gethash *secret-hashtable-size-key* object))
(let ((key (read-value stream))
(value (read-value stream)))
(setf (gethash key object) value)))
(remhash *secret-hashtable-size-key* object)
object)
(defmethod fill-object ((object persistent-object) stream)
(fill-persistent-object object stream)
object)
(defmethod fill-object ((object persistent-structure) stream)
(fill-persistent-object object stream)
object)
(defmethod fill-object ((object t) stream)
(user-fill-object stream object))
;;;
;;;
;;;
(defmethod user-fill-object (stream (object t))
(error "Please create a method \"USER-FILL-OBJECT (STREAM (OBJECT ~S))\"
and use subsequent calls to \"(USER-READ-COMPONENT-OBJECT STREAM)\" to read-in
and get the component objects of the object; assign these to the appropriate places
within the ~S and return the object!" (type-of object) (type-of object)))
(defmethod user-read-component-object (stream)
(read-value stream))
;;;
;;;
;;;
(defun read-value (stream)
(let ((marker (read-coded-marker stream)))
(cond ((or (= marker +object-marker+)
(= marker +structure-marker+)
(= marker +array-marker+)
(= marker +hashtable-marker+)
(= marker +user-responsibility-marker+))
(values
(retrieve (read-coded-integer stream))))
((= marker +nil-marker+)
(values
nil))
((= marker +integer-marker+)
(values
(read-coded-integer stream)))
((= marker +number-marker+)
(values
(read-coded-number stream)))
((= marker +unbound-marker+)
(values
nil))
(t (error "Bad marker ~A in read-value!" marker)))))
(defun probe-bound-p (stream)
(let ((marker (read-coded-marker stream)))
(prog1
(not (= marker +unbound-marker+))
(unread-byte*))))
(defmethod user-create-empty-object ((type t))
(error "Please create a method \"USER-CREATE-EMPTY-OBJECT (TYPE (EQL '~S))\"
that creates an EMPTY container object of type ~S!"
type type))
(defun construct-object (stream)
(loop
(let ((marker (read-coded-marker stream)))
(if (or (= marker +section-marker+)
(eq marker 'eof))
(return)
(let ((id (read-coded-integer stream)))
(store id
(cond ((= marker +string-marker+)
(read-coded-string stream))
((= marker +symbol-marker+)
(read-coded-symbol stream))
((= marker +cons-marker+)
(cons (incf *aux-counter*) nil))
((= marker +array-marker+)
(make-array (read-coded-list stream)))
((= marker +hashtable-marker+)
(let* ((no-of-entries (read-coded-integer stream))
(size (read-coded-integer stream))
(rehash-size (read-coded-integer stream))
(rehash-threshold (read-coded-number stream))
(test (read-coded-symbol stream))
(table (make-hash-table
:size size
:rehash-size rehash-size
:rehash-threshold rehash-threshold
:test test)))
(setf (gethash *secret-hashtable-size-key* table)
no-of-entries)
table))
((= marker +object-marker+)
(make-instance (read-value stream)
:allow-other-keys t
:dont-initialize t))
((= marker +structure-marker+)
(funcall (structure-initializer (read-value stream))))
((= marker +user-responsibility-marker+)
(let ((type (read-coded-symbol stream)))
(user-create-empty-object type)))
(t (error "Unknown marker: ~A." marker)))))))))
(defun initialize-object (stream)
(loop
(let ((io-id (read-coded-integer stream)))
(if (eq io-id 'eof)
(return)
(fill-object (retrieve io-id) stream)))))
;;;
;;;
;;;
(defmacro defpersistentclass (&rest rest)
`(progn ,@(let* ((name (first rest))
(superclasses (append (second rest) '(persistent-object)))
(body (third rest))
(slotnames (mapcar #'first body)))
(list
`(cl:defclass ,name ,superclasses
,(loop for slotspec in body collect
(remove :not-persistent slotspec)))
`(defmethod write-object-constructor ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(with-slots ,slotnames obj
,@(mapcan #'(lambda (slot)
(let ((name (first slot)))
(unless (member :not-persistent slot)
`((when (slot-boundp obj ',name)
(write-constructor ,name stream))))))
(reverse body)))
(call-next-method))
`(defmethod write-object-initializer ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(progn ;;with-slots ,slotnames obj
,@(mapcan #'(lambda (slot)
(let ((name (first slot)))
(unless (member :not-persistent slot)
`((if (slot-boundp obj ',name)
(write-referencer (slot-value obj ',name) stream)
(write-coded-marker stream +unbound-marker+))))))
(reverse body)))
(call-next-method))
`(defmethod fill-persistent-object ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(let (val unbound)
#+:allegro (declare (ignore-if-unused val unbound))
#+:lispworks (declare (ignore val unbound))
#+:mcl (declare (ccl:ignore-if-unused val unbound))
(with-slots ,slotnames obj
,@(mapcan #'(lambda (slot)
(let ((name (first slot)))
(unless (member :not-persistent slot)
`((if (probe-bound-p stream)
(setf ,name (read-value stream))
(read-value stream))))))
(reverse body)))
(call-next-method)))
(list 'quote name)))))
(defmacro defclass (&rest forms)
`(defpersistentclass .,forms))
;;;
;;;
;;;
(cl:defstruct structure-info
name
options
slot-specifications
slotnames
initializer)
(defvar *structures* (make-hash-table))
(defun find-structure (name &key (error-p t))
(let ((result (gethash name *structures*)))
(if (null result)
(if error-p
(error "Cannot find structure with name ~A." name)
nil)
result)))
(defun (setf find-structure) (new-value name)
(if (null new-value)
(remhash name *structures*)
(setf (gethash name *structures*) new-value)))
(defmacro with-structure-slots (structure-name slotnames obj &body forms)
`(symbol-macrolet ,(mapcar (lambda (slotname)
(list slotname
(structure-slot-accessor structure-name
slotname
obj)))
slotnames)
.,forms))
(defun structure-slot-accessor (structure-name slotname obj)
(let ((conc-name (or (second
(find ':conc-name
(structure-info-options (find-structure structure-name))
:key #'first))
(concatenate 'string (symbol-name structure-name) "-"))))
(if (symbolp conc-name)
(setf conc-name (symbol-name conc-name)))
(list
(intern (concatenate 'string
conc-name
(symbol-name slotname))
(symbol-package structure-name))
obj)))
(defun set-structure-initializer (structure-entry)
(let* ((user-defined-constructor
(find ':constructor
(structure-info-options structure-entry)
:key #'first))
(constructor
(if user-defined-constructor
(let ((arguments (required-arguments (third user-defined-constructor))))
(if arguments
#'(lambda ()
(apply (second user-defined-constructor)
(loop repeat (length arguments) collect nil)))
(second user-defined-constructor)))
(intern
(concatenate 'string "MAKE-"
(symbol-name (structure-info-name structure-entry)))
(symbol-package (structure-info-name structure-entry))))))
(setf (structure-info-initializer structure-entry) constructor)))
(defun required-arguments (arguments)
(if (null arguments)
nil
(if (member (first arguments) '(&rest &key &optional &allow-other-keys))
nil
(cons (first arguments)
(required-arguments (rest arguments))))))
(declaim (inline structure-initializer))
(defun structure-initializer (structure-name)
(structure-info-initializer (find-structure structure-name)))
(defun all-structure-slots (structure-entry)
(let ((included-structure-name
(structure-info-included-structure structure-entry)))
(if (null included-structure-name)
(structure-info-slotnames structure-entry)
(append (structure-info-slotnames structure-entry)
(all-structure-slots (find-structure included-structure-name))))))
(defun structure-info-included-structure (structure-entry)
(second (find ':include (structure-info-options structure-entry)
:key #'first)))
(defun real-structure-p (options)
(not (find ':type options :key #'first)))
(defmacro defpersistentstruct (name-or-name-and-specifications &rest doc-and-slots)
(let* ((name (if (consp name-or-name-and-specifications)
(first name-or-name-and-specifications)
name-or-name-and-specifications))
(options (if (consp name-or-name-and-specifications)
(rest name-or-name-and-specifications)
nil))
(include (second (find ':include options :key #'first)))
(documentation (if (stringp (first doc-and-slots))
(list (first doc-and-slots))))
(slots (if documentation
(rest doc-and-slots)
doc-and-slots))
(slot-specifications (mapcar (lambda (slot-spec)
(cond ((symbolp slot-spec) (list slot-spec nil))
((consp slot-spec) slot-spec)
(t (error "Illegal slot specification: ~A."
slot-spec))))
slots))
(slotnames (mapcar #'first slot-specifications))
all-slotnames
(structure-entry-var (gensym))
(structure-entry (find-structure name :error-p nil)))
(if structure-entry
(setf (structure-info-options structure-entry) options
(structure-info-slot-specifications structure-entry) slots
(structure-info-slotnames structure-entry) slotnames)
(setf structure-entry
(make-structure-info :name name
:options options
:slot-specifications slot-specifications
:slotnames slotnames)))
(set-structure-initializer structure-entry)
(setf (find-structure name) structure-entry)
(setf all-slotnames (all-structure-slots structure-entry))
(if (real-structure-p options)
`(progn
(let ((,structure-entry-var (find-structure ',name :error-p nil)))
(if ,structure-entry-var
(setf (structure-info-options ,structure-entry-var) ',options
(structure-info-slot-specifications ,structure-entry-var) ',slots
(structure-info-slotnames ,structure-entry-var) ',slotnames)
(setf ,structure-entry-var
(make-structure-info :name ',name
:options ',options
:slot-specifications ',slot-specifications
:slotnames ',slotnames)))
(set-structure-initializer ,structure-entry-var)
(setf (find-structure ',name) ,structure-entry-var))
(cl:defstruct (,name .,(if (null include)
(cons (list :include 'persistent-structure)
options)
options))
,@documentation
.,slot-specifications)
(defmethod write-object-constructor ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(with-structure-slots ,name ,all-slotnames obj
,@(mapcan #'(lambda (slotname)
`((write-constructor ,slotname stream)))
all-slotnames)))
(defmethod write-object-initializer ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(with-structure-slots ,name ,all-slotnames obj
,@(mapcan #'(lambda (slotname)
`((write-referencer ,slotname stream)))
all-slotnames)))
(defmethod fill-persistent-object ((obj ,name) stream)
#+:allegro (declare (ignore-if-unused stream))
#+:lispworks (declare (ignore stream))
#+:mcl (declare (ccl:ignore-if-unused stream))
(with-structure-slots ,name ,all-slotnames obj
,@(mapcan #'(lambda (slotname)
`((setf ,slotname
(read-value stream))))
all-slotnames)))
',name)
`(cl:defstruct (,name .,options)
,@documentation
.,slot-specifications))))
(defmacro defstruct (&rest forms)
`(defpersistentstruct .,forms))
;;;
;;;
;;;
(defconstant +file-type-marker+ 66647963)
(defun write-section-separator (stream)
(write-coded-marker stream +section-marker+))
(defun generate-temp-filename (filename)
(let* ((pathname (pathname filename))
(name (pathname-name pathname))
new-name)
(loop for i from 1 to 100 do
(when (not (probe-file (setf new-name
(merge-pathnames (concatenate 'string
name
"_"
(format nil "~D" i))
pathname))))
(return-from generate-temp-filename new-name)))
(error "Cannot generate name for temp file.")))
(defun make-object-persistent (obj fn &optional (package *package*))
(let ((filename (generate-temp-filename fn)))
(handler-case
(progn
(with-open-file (stream filename
:element-type 'unsigned-byte
:direction :output :if-exists :supersede
:if-does-not-exist :create)
(let ((*package* package))
(reset)
(write-coded-integer stream +file-type-marker+)
(write-coded-string stream
(make-string +n-bytes-for-written-objects+
:initial-element #\space))
(write-coded-string stream (package-name package))
(write-coded-integer stream +persistence-version+)
(write-constructor (list obj) stream)
(write-section-separator stream)
(maphash #'(lambda (key value)
(declare (ignore value))
(write-initializer key stream))
*written-objects*)))
(when (> *io-id-counter* +maximum-written-objects+)
(error "Maximum number of objects per file (~D) exceeded."
+maximum-written-objects+))
(with-open-file (stream filename
:element-type 'unsigned-byte
:direction :output :if-exists :overwrite
:if-does-not-exist :create)
(write-coded-integer stream +file-type-marker+)
(write-coded-string stream
(format nil
(concatenate 'string
"~"
(format nil "~D" +n-bytes-for-written-objects+)
",d")
*io-id-counter*)))
(when (probe-file fn)
(delete-file fn ))
(rename-file filename fn)
(format nil "~A objects and ~A references have been written to ~A." *io-id-counter* *ref-counter* fn))
(error (c)
(format *error-output* "~A" c)
(when (probe-file filename)
(delete-file filename))
nil))))
(defun load-persistent-object (fn &key (initialization-protocol t))
(with-open-file (stream fn :direction :input :element-type 'unsigned-byte)
(let ((file-type-marker (read-coded-integer stream)))
(unless (= file-type-marker +file-type-marker+)
(error "File ~S is not a Racer dump file." fn))
(let* ((n-of-objects-to-read (read-from-string (read-coded-string stream)))
(package-name (read-coded-string stream))
(package (find-package package-name))
(*package* (or package
(error "Cannot restore object: Package ~S not found." package-name)))
(version (read-coded-integer stream)))
(unless (= version +persistence-version+)
(error "Dump file format of ~A not compatible with current version of Racer." fn))
(read-reset n-of-objects-to-read)
(construct-object stream)
(initialize-object stream)
(when initialization-protocol
(dotimes (i (+ 2 *io-id-counter*))
(let ((obj (bvref *read-objects* i)))
(when (or (typep obj 'persistent-object)
(typep obj 'persistent-structure))
(initialize-loaded-persistent-object obj)))))
(let ((result (first (retrieve 1))))
(setf *read-objects* nil)
(values result
(format nil "Loaded ~A objects from ~A." (+ 2 *io-id-counter*) fn)
#|(loop as i from 1 to *io-id-counter* when (typep (retrieve i) 'persistent-object)
collect (retrieve i))|#))))))
| 33,791 | Common Lisp | .lisp | 844 | 31.759479 | 112 | 0.619051 | lambdamikel/Common-Lisp-Persistency-Manager | 16 | 3 | 0 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | f751605aea56873a9c80930b2f863cf5e67794c5353c3f51a2cfea3285a9e22f | 7,793 | [
-1
] |
7,794 | persistence-sysdcl.lisp | lambdamikel_Common-Lisp-Persistency-Manager/src/persistence-sysdcl.lisp | ;;; -*- Mode: LISP; Syntax: Common-Lisp; Package: CL-USER -*-
(in-package :cl-user)
(setf (logical-pathname-translations "base")
'(("**;*.*" "~/**/*.*")))
(setf (logical-pathname-translations "persistence")
'(("**;*.*" "base:persistence;**;*.*")))
(load "persistence:define-system.lisp")
(define-system persistence
(:default-pathname "persistence:")
(:serial
"persistence-package"
"persistence2"
"tests"))
(defun load-persistence-manager (&optional force-p)
(load-system 'persistence :force-p force-p))
(load-persistence-manager t)
(princ (persistence::test))
;; you need about ~500 KB of stack for this!
;; just hit continues / extend stack when you get
;; a stack overflow
(princ (persistence::run-stest))
;; you need about ~500 KB of stack for this!
;; just hit continues / extend stack when you get
;; a stack overflow
(princ (persistence::run-test))
| 905 | Common Lisp | .lisp | 25 | 33.2 | 61 | 0.683968 | lambdamikel/Common-Lisp-Persistency-Manager | 16 | 3 | 0 | GPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 0a092d5f33e91e31e1966b964143946c8c06d6b76a26e410fe1dbf2b757c1a84 | 7,794 | [
-1
] |
7,816 | lhstats.lisp | mrc_lhstats/lhstats.lisp | ;;;; lhstats.lisp
;;; This comes in large part from Larry Hunter but has been significantly
;;; augmented by Jeff Shrager, partly from his own stats libraries, and
;;; partly from open source stuff borrowed from around the web. Citations
;;; and acknowledgements are given where possible.
;;; ---------------------- Larry Hunter's Code ----------------------
;;; Statistical functions in Common Lisp. Version 1.01 July 27, 2001
;;;
;;; This code is copyright (c) 2000 by Larry Hunter ([email protected])
;;; except where otherwise noted.
;;; Thanks to Paul Cohen for the original CLASP package. Thanks also to bug
;;; reports from Rob St. Amant.
;;;
;;; This program is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by the
;;; Free Software Foundation; either version 2 of the License, or (at your
;;; option) any later version.
;;; This program is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;; General Public License for more details.
;;; You should have received a copy of the GNU General Public License along
;;; with this program; if not, write to the Free Software Foundation, Inc.,
;;; 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
;;; The formulas and methods used are largely taken from Bernard Rosner,
;;; "Fundamentals of Biostatistics," 5th edition. "Rosner x" is a page
;;; number. Some numeric functions were taken from CLASP, a 1994 common
;;; lisp package that implemented some of the statistical functions from
;;; "Numeric recipes in C" For CLASP functions, see copyright notice below.
;;; These abreviations used in function and variable names:
;;; ci = confidence interval
;;; cdf = cumulative density function
;;; ge = greater than or equal to
;;; le = less than or equal to
;;; pdf = probability density function
;;; sd = standard deviation
;;; rxc = rows by columns
;;; sse = sample size estimate
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Functions provided:
;;;
;;; Descriptive statistics
;;; Mean, median, mode, geometric mean, range, percentile, variance,
;;; standard-deviation (sd), coefficient-of-variation,
;;; standard-error-of-the-mean
;;;
;;; Distributional functions
;;; Poisson & Binomial
;;; binomial-probability, binomial-cumulative-probability,
;;; binomial-ge-probability, poisson-probability,
;;; poisson-cumulative-probability, poisson-ge-probability, Normal
;;; normal-pdf, convert-to-standard-normal, phi, z, t-distribution,
;;; chi-square, chi-square-cdf
;;;
;;; Confidence Intervals
;;; binomial-probability-ci, poisson-mu-ci, normal-mean-ci,
;;; normal-mean-ci-on-sequences, normal-variance-ci,
;;; normal-variance-ci-on-sequence, normal-sd-ci
;;;
;;; Hypothesis tests (parametric)
;;; z-test, z-test-on-sequence, t-test-one-sample,
;;; t-test-one-sample-on-sequence, t-test-paired,
;;; t-test-paired-on-sequences, t-test-two-sample,
;;; t-test-two-sample-on-sequences, chi-square-test-one-sample, f-test,
;;; binomial-test-one-sample, binomial-test-two-sample, fisher-exact-test,
;;; mcnemars-test, poisson-test-one-sample
;;;
;;; Hypothesis tests (non-parametric)
;;; sign-test, sign-test-on-sequence, wilcoxon-signed-rank-test,
;;; chi-square-test-rxc, chi-square-test-for-trend
;;; Sample size estimates
;;; t-test-one-sample-sse, t-test-two-sample-sse
;;; t-test-paired-sse, binomial-test-one-sample-sse,
;;; binomial-test-two-sample-sse,
;;; binomial-test-paired-sse, correlation-sse
;;; Correlation and Regression
;;; linear-regression, correlation-coefficient,
;;; correlation-test-two-sample, spearman-rank-correlation
;;; Significance test functions
;;; t-significance, f-significance (chi square significance is calculated
;;; from chi-square-cdf in various ways depending on the problem).
;;; Utilities
;;; random-sample, random-pick, bin-and-count, fishers-z-transform,
;;; mean-sd-n, square, choose, permutations, round-float
(eval-when (:compile-toplevel)
(declaim (optimize (speed 3) (safety 1) (debug 1))))
(in-package :statistics)
;;;;; Macros
;; This macro makes assertions more readable. There are several special
;; types defined: :probability (:prob), :positive-integer (:posint),
;; :positive-number (:posnum), :number-sequence (:numseq),
;; :positive-integer-sequence (:posintseq), :probability-sequence
;; (:probseq), :nonzero-number-sequence (:nonzero-numseq) and :percentage
;; (:percent). Other assertions are assumed to be internal types. The
;; arguments to test-variables are lists. The first element of the list is
;; a variable name, and the second element is either a special or built-in
;; type. If the variable binding is not of the type specified, and error is
;; signalled indicating the problem. One variable may have multiple type
;; requirements, which are conjunctive.
(eval-when (:compile-toplevel :load-toplevel :execute)
(defmacro test-variables (&rest args)
(let ((assertions nil))
(dolist (arg args (append `(or ,@(nreverse assertions))))
(let* ((name (first arg))
(type (second arg))
(test (case type
((:probability :prob)
`(and (numberp ,name) (not (minusp ,name)) (<= ,name 1)))
((:positive-integer :posint)
`(and (integerp ,name) (plusp ,name)))
((:positive-number :posnum)
`(and (numberp ,name) (plusp ,name)))
((:number-sequence :numseq)
`(and (typep ,name 'sequence) (every #'numberp ,name)
(not (null ,name))))
((:nonzero-number-sequence :nonzero-numseq)
`(and (typep ,name 'sequence) (not (null ,name))
(every (lambda (x) (and (numberp x) (not (= 0 x))))
,name)))
((:probability-sequence :probseq)
`(and (typep ,name 'sequence) (not (null ,name))
(every (lambda (x) (and (numberp x) (not (minusp x))
(<= x 1.0))) ,name)))
((:positive-integer-sequence :posintseq)
`(and (typep ,name 'sequence) (not (null ,name))
(every (lambda (x) (and (typep x 'integer) (plusp
x)))
,name)))
(:percentage
`(and (numberp ,name) (plusp ,name) (<= ,name 100)))
(:test (third arg))
(t `(typep ,name ',type))))
(message `(error
,(if (eql type :test)
"~a"
(format nil "~a = ~~a is not a ~a" name
(case type
((:positive-integer :posint)
"positive integer")
((:positive-number :posnum)
"positive number")
((:probability :prob) "probability")
((:number-sequence :numseq)
"sequence of numbers")
((:nonzero-number-sequence
:nonzero-numseq)
"sequence of non-zero numbers")
((:positive-integer-sequence :posintseq)
"sequence of positive integers")
((:probability-sequence :probseq)
"sequence of probabilities")
((:percent :percentile) "percent")
(t type))))
,name)))
(push `(unless ,test ,message) assertions)))))
;; SQUARE
(defmacro square (x)
`(* ,x ,x))
(defmacro underflow-goes-to-zero (&body body)
"Protects against floating point underflow errors and sets the value to 0.0 instead."
`(handler-case
(progn ,@body)
(floating-point-underflow (condition)
(declare (ignore condition))
(values 0.0d0))))
) ;end eval-when
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Descriptive statistics
;;;
;; Rosner 10
(defun mean (sequence)
(test-variables (sequence :numseq))
(/ (reduce #'+ sequence) (length sequence)))
;; Rosner 12 (and 19)
(defun median (sequence)
(test-variables (sequence :numseq))
(percentile sequence 50))
;; Rosner 14
;; Rob St. Amant <[email protected]> suggested using a hash table
;; instead of an alist.
(defun mode (sequence)
"Returns two values: a list of the modes and the number of times
they occur."
(test-variables (sequence :numseq))
(let ((count-table (make-hash-table))
mode (mode-count 0))
(map nil (lambda (elt) (incf (gethash elt count-table 0))) sequence)
(maphash (lambda (key value)
(when (> value mode-count)
(setf mode key
mode-count value)))
count-table)
(values mode mode-count)))
;; Rosner 16
(defun geometric-mean (sequence &optional (base 10))
(test-variables (sequence :nonzero-numseq) (base :posnum))
(expt base (mean (map 'list (lambda (x) (log x base)) sequence))))
;; Rosner 18
(defun range (sequence)
(test-variables (sequence :numseq))
(- (reduce #'max sequence) (reduce #'min sequence)))
;; Rosner 19
;; NB: Aref is 0 based!
(defun percentile (sequence percent)
(test-variables (sequence :numseq) (percent :percentage))
(let* ((sorted-vect (coerce (sort (copy-seq sequence) #'<) 'simple-vector))
(n (length sorted-vect))
(k (* n (/ percent 100)))
(floor-k (floor k)))
(if (= k floor-k)
(/ (+ (aref sorted-vect k)
(aref sorted-vect (1- k)))
2)
(aref sorted-vect floor-k))))
;; Rosner 21
(defun variance (sequence)
(test-variables (sequence :numseq))
(let ((mean (mean sequence))
(n (length sequence)))
(/ (reduce #'+ (map 'list (lambda (x) (square (- mean x))) sequence))
(1- n))))
;; Rosner 21
(defun standard-deviation (sequence)
(test-variables (sequence :numseq))
(let ((mean (mean sequence))
(n (length sequence)))
(sqrt (/ (reduce #'+ (map 'list (lambda (x) (square (- mean x))) sequence))
(1- n)))))
(defun sd (sequence)
(standard-deviation sequence))
;; Rosner 24
(defun coefficient-of-variation (sequence)
(* 100 (/ (standard-deviation sequence) (mean sequence))))
;; Rosner 172
(defun standard-error-of-the-mean (sequence)
(/ (standard-deviation sequence) (sqrt (length sequence))))
(defun standard-error (sequence)
(standard-error-of-the-mean sequence))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Distributional functions
;;;
;;;
;;; Binomial and Poisson distributions
;;;
;; exact: Rosner 93, approximate 105
(defun binomial-probability (n k p)
"P(X=k) for X a binomial random variable with parameters n &
p. Binomial expectations for seeing k events in N trials, each having
probability p. Use the Poisson approximation if N>100 and P<0.01."
(test-variables (n :posint) (p :prob)
("K must be between 0 and N (inclusive)" :test (and (>= k 0) (<= k n))))
(if (and (> n 100) (< p 0.01))
(poisson-probability (* n p) k)
(let ((p (coerce p 'double-float)))
(* (choose n k)
(expt p k)
(expt (- 1 p) (- n k))))))
;; Rosner 94
(defun binomial-cumulative-probability (n k p)
"P(X<k) for X a binomial random variable with parameters n &
p. Bionomial expecations for fewer than k events in N trials, each
having probability p."
(test-variables (n :posint) (k :posint) (p :prob)
("K must be less than or equal to N" :test (<= k n)))
(let ((sum-up-to-k-1 0d0))
(dotimes (i k sum-up-to-k-1)
(incf sum-up-to-k-1 (binomial-probability n i p)))))
;; Rosner 94
(defun binomial-ge-probability (n k p)
"The probability of k or more occurances in N events, each with
probability p."
(- 1 (binomial-cumulative-probability n k p)))
;; Just for convenience later, binomial-le-probability
(defun binomial-le-probability (n k p)
(test-variables (n :posint) (k :posint) (p :prob)
("K must be less than or equal to N" :test (<= k n)))
(let ((sum-up-to-k 0d0))
(dotimes (i (1+ k) sum-up-to-k)
(incf sum-up-to-k (binomial-probability n i p)))))
;; Rosner 100
(defun poisson-probability (mu k)
"Probability of seeing k events over a time period when the expected
number of events over that time is mu."
(test-variables (mu :posnum) (k :posint))
(let ((mu (coerce mu 'double-float)))
(/ (* (exp (- mu)) (expt mu k))
(factorial k))))
;; Rosner 197
(defun poisson-cumulative-probability (mu k)
"Probability of seeing fewer than K events over a time period when
the expected number events over that time is mu."
(test-variables (mu :posnum) (k :posint))
(if (< k 170)
(let ((sum 0d0))
(dotimes (x k sum)
(incf sum (poisson-probability mu x))))
(let ((mu (coerce mu 'double-float))
(k (coerce k 'double-float)))
(- 1d0 (gamma-incomplete k mu)))))
(defun poisson-ge-probability (mu x)
"Probability of X or more events when expected is mu."
(- 1 (poisson-cumulative-probability mu x)))
;;;
;;; Normal distributional functions
;;;
;; Rosner 115
(defun Normal-pdf (x mu sigma)
"The probability density function (PDF) for a normal distribution
with mean mu and variance sigma at point x."
(test-variables (x number) (mu number) (sigma :posnum))
(* (/ (* (sqrt (* 2 pi)) sigma))
(exp (* (- (/ (* 2 (square sigma)))) (square (- x mu))))))
;; Rosner 130
(defun convert-to-standard-normal (x mu sigma)
"Convert X from a Normal distribution with mean mu and variance
sigma to standard normal"
(test-variables (x number) (mu number) (sigma :posnum))
(/ (- x mu) sigma))
;; Rosner 125
(defun phi (x)
"the CDF of standard normal distribution. Adopted from CLASP 1.4.3,
see copyright notice at http://eksl-www.cs.umass.edu/clasp.html"
(test-variables (x number))
(* .5 (+ 1.0 (error-function (/ x (sqrt 2.0))))))
;; Rosner 128.
(defun z (percentile &key (epsilon 1d-15))
"The inverse normal function, P(X<Zu) = u where X is distributed as
the standard normal. Uses binary search."
(test-variables (percentile :prob))
(let ((target (coerce percentile 'double-float)))
(do ((min -9d0 min)
(max 9d0 max)
(guess 0d0 (+ min (/ (- max min) 2d0))))
((< (- max min) epsilon) guess)
(let ((result (coerce (phi guess) 'double-float)))
(if (< result target)
(setq min guess)
(setq max guess))))))
;; Rosner 178
(defun t-distribution (dof percentile)
"Returns the point which is the indicated percentile in the T
distribution with dof degrees of freedom. Adopted from CLASP 1.4.3,
http://eksl-www.cs.umass.edu/clasp.html"
(test-variables (dof :posint) (percentile :prob))
(find-critical-value
(lambda (x) (t-significance x dof :tails :positive))
(- 1 percentile)))
;; Rosner 187
(defun chi-square (dof percentile)
"Returns the point which is the indicated percentile in the Chi
Square distribution with dof degrees of freedom."
(test-variables (dof :posint) (percentile :prob))
(find-critical-value (lambda (x) (chi-square-cdf x dof))
(- 1 percentile)))
(defun chi-square-cdf (x dof)
"Computes the left hand tail area under the chi square distribution
under dof degrees of freedom up to X. Adopted from CLASP 1.4.3,
http://eksl-www.cs.umass.edu/clasp.html"
(test-variables (x :posnum) (dof :posint))
(multiple-value-bind (cdf ignore)
(gamma-incomplete (* 0.5 dof) (* 0.5 x))
(declare (ignore ignore))
cdf))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Confidence intervals
;;;
;; Rosner 193 (approximate) & 194 (exact)
(defun binomial-probability-ci (n p alpha &key exact?)
"Confidence intervals on a binomial probability. If a binomial
probability of p has been observed in N trials, what is the 1-alpha
confidence interval around p? Approximate (using normal theory
approximation) when npq >= 10 unless told otherwise"
(test-variables (n :posint) (p :prob) (alpha :prob))
(if (and (> (* n p (- 1 p)) 10) (not exact?))
(let ((difference (* (z (- 1 (/ alpha 2)))
(sqrt (/ (* p (- 1 p)) n)))))
(values (- p difference) (+ p difference)))
(values (find-critical-value
(lambda (p1) (binomial-cumulative-probability n (floor (* p n)) p1))
(- 1 (/ alpha 2)))
(find-critical-value
(lambda (p2) (binomial-cumulative-probability n (1+ (floor (* p n))) p2))
(/ alpha 2)))))
;; Rosner 197
(defun poisson-mu-ci (x alpha)
"Confidence interval for the Poisson parameter mu
Given x observations in a unit of time, what is the 1-alpha confidence
interval on the Poisson parameter mu (= lambda*T)?
Since find-critical-value assumes that the function is monotonic
increasing, adjust the value we are looking for taking advantage of
reflectiveness."
(test-variables (x :posnum) (alpha :prob))
(values
(find-critical-value
(lambda (mu) (poisson-cumulative-probability mu (1- x)))
(- 1 (/ alpha 2)))
(find-critical-value
(lambda (mu) (poisson-cumulative-probability mu x))
(/ alpha 2))))
;; Rosner 180
(defun normal-mean-ci (mean sd n alpha)
"Confidence interval for the mean of a normal distribution
The 1-alpha percent confidence interval on the mean of a normal
distribution with parameters mean, sd & n."
(test-variables (mean number) (sd :posnum) (n :posint) (alpha :prob))
(let ((t-value (t-distribution (1- n) (- 1 (/ alpha 2)))))
(values (- mean (* t-value (/ sd (sqrt n))))
(+ mean (* t-value (/ sd (sqrt n)))))))
(defun normal-mean-ci-on-sequence (sequence alpha)
"The 1-alpha confidence interval on the mean of a sequence of
numbers drawn from a Normal distribution."
(test-variables (alpha :prob)) ; sequence tested by mean-sd-n
(multiple-value-call #'normal-mean-ci (mean-sd-n sequence) alpha))
;; Rosner 190
(defun normal-variance-ci (variance n alpha)
"The 1-alpha confidence interval on the variance of a sequence of
numbers drawn from a Normal distribution."
(test-variables (variance :posnum) (n :posint) (alpha :prob))
(let ((chi-square-low (chi-square (1- n) (- 1 (/ alpha 2))))
(chi-square-high (chi-square (1- n) (/ alpha 2)))
(numerator (* (1- n) variance)))
(values (/ numerator chi-square-low) (/ numerator chi-square-high))))
(defun normal-variance-ci-on-sequence (sequence alpha)
(test-variables (sequence :numseq) (alpha :prob))
(let ((variance (variance sequence))
(n (length sequence)))
(normal-variance-ci variance n alpha)))
;; Rosner 190
(defun normal-sd-ci (sd n alpha)
"As normal-variance-ci-on-sequence, but a confidence inverval for
the standard deviation."
(multiple-value-bind (low high)
(normal-variance-ci (square sd) n alpha)
(values (sqrt low) (sqrt high))))
(defun normal-sd-ci-on-sequence (sequence alpha)
(test-variables (sequence :numseq) (alpha :prob))
(let ((sd (standard-deviation sequence))
(n (length sequence)))
(normal-sd-ci sd n alpha)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Hypothesis testing
;;;
;; Rosner 228
(defun z-test (x-bar n &key (mu 0) (sigma 1) (tails :both))
"The significance of a one sample Z test for the mean of a normal
distribution with known variance.
mu is the null hypothesis mean, x-bar is the observed mean, sigma is
the standard deviation and N is the number of observations. If tails
is :both, the significance of a difference between x-bar and mu. If
tails is :positive, the significance of x-bar is greater than mu, and
if tails is :negative, the significance of x-bar being less than mu.
Returns a p value."
(test-variables (x-bar number) (n :posint) (mu number) (sigma :posnum))
(let ((z (/ (- x-bar mu) (/ sigma (sqrt n)))))
(ecase tails
(:both (if (< z 0)
(* 2 (phi z))
(* 2 (- 1 (phi z)))))
(:negative (phi z))
(:positive (- 1 (phi z))))))
(defun z-test-on-sequence (sequence &key (mu 0) (sigma 1) (tails :both))
(test-variables (sequence :numseq)) ; the rest handled by z-test
(let ((x-bar (mean sequence))
(n (length sequence)))
(z-test x-bar n :mu mu :sigma sigma :tails tails)))
;; Rosner 216
(defun t-test-one-sample (x-bar sd n mu &key (tails :both))
"The significance of a one sample T test for the mean of a normal
distribution with unknown variance. X-bar is the observed mean, sd is
the observed standard deviation, N is the number of observations and
mu is the test mean.
See also t-test-one-sample-on-sequence"
(test-variables (x-bar number) (sd :posnum) (n :posint) (mu number))
(t-significance (/ (- x-bar mu) (/ sd (sqrt n))) (1- n) :tails tails))
(defun t-test-one-sample-on-sequence (sequence mu &key (tails :both))
"As t-test-one-sample, but calculates the observed values from a
sequence of numbers."
(multiple-value-call #'t-test-one-sample
(mean-sd-n sequence) mu :tails tails))
;; Rosner 276
(defun t-test-paired (d-bar sd n &key (tails :both))
"The significance of a paired t test for the means of two normal
distributions in a longitudinal study. D-bar is the mean difference,
sd is the standard deviation of the differences, N is the number of
pairs."
(test-variables (d-bar number) (sd :posnum) (n :posint))
(t-significance (/ d-bar (/ sd (sqrt n))) (1- n) :tails tails))
;; Rosner 276
(defun t-test-paired-on-sequences (before after &key (tails :both))
"The significance of a paired t test for means of two normal
distributions in a longitudinal study. Before is a sequence of before
values, after is the sequence of paired after values (which must be
the same length as the before sequence)."
(test-variables (before :numseq) (after :numseq)
("Before and after sequences must be of equal length"
:test (= (length before) (length after))))
(multiple-value-call #'t-test-paired
(mean-sd-n (map 'list #'- before after)) :tails tails))
;; Rosner 282, 294, 297
(defun t-test-two-sample (x-bar1 sd1 n1 x-bar2 sd2 n2 &key
(variances-equal? :test)
(variance-significance-cutoff 0.05)
(tails :both))
"The significance of the difference of two means (x-bar1 and x-bar2)
with standard deviations sd1 and sd2, and sample sizes n1 and n2
respectively. The form of the two sample t test depends on whether
the sample variances are equal or not. If the variable
variances-equal? is :test, then we use an F test and the
variance-significance-cutoff to determine if they are equal. If the
variances are equal, then we use the two sample t test for equal
variances. If they are not equal, we use the Satterthwaite method,
which has good type I error properties (at the loss of some power)."
(test-variables (x-bar1 number) (sd1 :posnum) (n1 :posint)
(x-bar2 number) (sd2 :posnum) (n2 :posint))
(let (t-statistic dof)
(if (ecase variances-equal?
(:test (> (f-test (square sd1) n1 (square sd2) n2 :tails tails)
variance-significance-cutoff))
((t :yes :equal) t)
((nil :no :unequal) nil))
(let ((s (sqrt (/ (+ (* (1- n1) (square sd1))
(* (1- n2) (square sd2)))
(+ n1 n2 -2)))))
(setq t-statistic (/ (- x-bar1 x-bar2)
(* s (sqrt (+ (/ n1) (/ n2)))))
dof (+ n1 n2 -2)))
(let* ((variance-ratio1 (/ (square sd1) n1))
(variance-ratio2 (/ (square sd2) n2)))
(setq t-statistic (/ (- x-bar1 x-bar2)
(sqrt (+ variance-ratio1 variance-ratio2)))
dof (round (/ (square (+ variance-ratio1 variance-ratio2))
(+ (/ (square variance-ratio1) (1- n1))
(/ (square variance-ratio2) (1- n2))))))))
(t-significance t-statistic dof :tails tails)))
(defun t-test-two-sample-on-sequences (sequence1 sequence2 &key
(variance-significance-cutoff 0.05)
(tails :both))
"Same as t-test-two-sample, but providing the sequences rather than
the summaries."
(multiple-value-call #'t-test-two-sample
(mean-sd-n sequence1) (mean-sd-n sequence2) :tails tails
:variance-significance-cutoff variance-significance-cutoff))
;; Rosner 290
(defun f-test (variance1 n1 variance2 n2 &key (tails :both))
"F test for the equality of two variances"
(test-variables (variance1 :posnum) (n1 :posint) (variance2 :posnum) (n2 :posint))
(let ((significance (f-significance (/ variance1 variance2) (1- n1) (1- n2)
(not (eql tails :both)))))
(ecase tails
(:both significance)
(:positive (if (> variance1 variance2) significance (- 1 significance)))
(:negative (if (< variance1 variance2) significance (- 1 significance))))))
;; Rosner 246
(defun chi-square-test-one-sample (variance n sigma-squared &key (tails :both))
"The significance of a one sample Chi square test for the variance of
a normal distribution. Variance is the observed variance, N is the
number of observations, and sigma-squared is the test variance."
(test-variables (variance :posnum) (n :posint) (sigma-squared :posnum))
(let ((cdf (chi-square-cdf (/ (* (1- n) variance) sigma-squared) (1- n))))
(ecase tails
(:negative cdf)
(:positive (- 1 cdf))
(:both (if (<= variance sigma-squared)
(* 2 cdf)
(* 2 (- 1 cdf)))))))
;; Rosner 249
(defun binomial-test-one-sample (p-hat n p &key (tails :both) (exact? nil))
"The significance of a one sample test for the equality of an observed
probability p-hat to an expected probability p under a binomial
distribution with N observations. Use the normal theory approximation
if n*p*(1-p) > 10 (unless the exact flag is true)."
(test-variables (p-hat :prob) (n :posint) (p :prob))
(let ((q (- 1 p)))
(if (and (> (* n p q) 10) (not exact?))
(let ((z (/ (- p-hat p) (sqrt (/ (* p q) n)))))
(ecase tails
(:negative (phi z))
(:positive (- 1 (phi z)))
(:both (* 2 (if (<= p-hat p) (phi z) (- 1 (phi z)))))))
(let* ((observed (round (* p-hat n)))
(probability-more-extreme
(if (<= p-hat p)
(binomial-cumulative-probability n observed p)
(binomial-ge-probability n observed p))))
(ecase tails
((:negative :positive) probability-more-extreme)
(:both (min (* 2 probability-more-extreme) 1.0)))))))
;; Rosner 357
(defun binomial-test-two-sample (p-hat1 n1 p-hat2 n2 &key (tails :both)
(exact? nil))
"Are the observed probabilities of an event (p-hat1 and p-hat2) in
N1/N2 trials different? The normal theory method implemented here.
The exact test is Fisher's contingency table method, below."
(test-variables (p-hat1 :prob) (n1 :posint) (p-hat2 :prob) (n2 :posint))
(let* ((p-hat (/ (+ (* p-hat1 n1) (* p-hat2 n2)) (+ n1 n2)))
(q-hat (- 1 p-hat))
(z (/ (- (abs (- p-hat1 p-hat2)) (+ (/ (* 2 n1)) (/ (* 2 n2))))
(sqrt (* p-hat q-hat (+ (/ n1) (/ n2)))))))
(if (and (> (* n1 p-hat q-hat) 5)
(> (* n2 p-hat q-hat) 5)
(not exact?))
(* (- 1 (phi z)) (if (eql tails :both) 2 1))
(let ((contingency-table (make-array '(2 2))))
(setf (aref contingency-table 0 0) (* p-hat1 n1)
(aref contingency-table 0 1) (- 1 (* p-hat1 n1))
(aref contingency-table 1 0) (* p-hat2 n2)
(aref contingency-table 1 1) (- 1 (* p-hat2 n2)))
(fisher-exact-test contingency-table :tails tails)))))
;; Rosner 371
(defun fisher-exact-test (contingency-table &key (tails :both))
"Fisher's exact test. Gives a p value for a particular 2x2
contingency table"
(flet ((table-probability (a b c d)
(let ((n (+ a b c d)))
(/ (* (factorial (+ a b)) (factorial (+ c d))
(factorial (+ a c)) (factorial (+ b d)))
(* (factorial n) (factorial a) (factorial b)
(factorial c) (factorial d))))))
(let ((a (aref contingency-table 0 0))
(b (aref contingency-table 0 1))
(c (aref contingency-table 1 0))
(d (aref contingency-table 1 1)))
(test-variables (a number) (b number) (c number) (d number))
(let* ((row-margin1 (+ a b))
(row-margin2 (+ c d))
(column-margin1 (+ a c))
(column-margin2 (+ b d))
(n (+ a b c d))
(table-probabilities
(make-array (1+ (min row-margin1 row-margin2 column-margin1
column-margin2)))))
;; rearrange so that the first row and column marginals are
;; smallest. Only need to change first margins and a.
(cond ((and (< row-margin2 row-margin1) (< column-margin2 column-margin1))
(psetq a d
row-margin1 row-margin2
column-margin1 column-margin2))
((< row-margin2 row-margin1)
(psetq a c
row-margin1 row-margin2))
((< column-margin2 column-margin1)
(psetq a b
column-margin1 column-margin2)))
(dotimes (i (length table-probabilities))
(let* ((test-a i)
(test-b (- row-margin1 i))
(test-c (- column-margin1 i))
(test-d (- n (+ test-a test-b test-c))))
(setf (aref table-probabilities i)
(table-probability test-a test-b test-c test-d))))
(let ((above (reduce #'+ (subseq table-probabilities 0 (1+ a))))
(below (reduce #'+ (subseq table-probabilities a))))
(float
(ecase tails
((:both) (* 2 (min above below)))
((:positive) below)
((:negative) above))
1d0))))))
;; Rosner 379 and 381
(defun mcnemars-test (a-discordant-count b-discordant-count &key (exact? nil))
"McNemar's test for correlated proportions, used for longitudinal
studies. Look only at the number of discordant pairs (one treatment is
effective and the other is not). If the two treatments are A and B,
a-discordant-count is the number where A worked and B did not, and
b-discordant-count is the number where B worked and A did not."
(test-variables (a-discordant-count :posint) (b-discordant-count :posint))
(let ((n (+ a-discordant-count b-discordant-count)))
(if (and (> n 20) (not exact?))
(let ((x2 (/ (square
(- (abs (- a-discordant-count b-discordant-count)) 1))
n)))
(- 1 (chi-square-cdf x2 1)))
(cond ((= a-discordant-count b-discordant-count) 1.0)
((< a-discordant-count b-discordant-count)
(* 2 (binomial-le-probability n a-discordant-count 1/2)))
(t (* 2 (binomial-ge-probability n a-discordant-count 1/2)))))))
;; Rosner 256 (approximation on 259)
(defun poisson-test-one-sample (observed mu &key (tails :both) (approximate? nil))
"The significance of a one sample test for the equality of an observed
number of events (observed) and an expected number mu under the
poisson distribution. Normal theory approximation is not that great,
so don't use it unless told."
(test-variables (observed :posnum) (mu :posnum))
(if approximate?
(let ((x-square (/ (square (- observed mu)) mu)))
(- 1 (chi-square-cdf x-square 1)))
(let ((probability-more-extreme
(if (< observed mu)
(poisson-cumulative-probability mu observed)
(poisson-ge-probability mu observed))))
(ecase tails
((:negative :positive) probability-more-extreme)
(:both (min (* 2 probability-more-extreme) 1.0))))))
;;;
;;; Non-parametric hypothesis testing
;;;
;; Rosner 335-7.
(defun sign-test (plus-count minus-count &key (exact? nil) (tails :both))
"Really just a special case of the binomial one sample test with p =
1/2. The normal theory version has a correction factor to make it a
better approximation."
(test-variables (plus-count :posint) (minus-count :posint))
(let* ((n (+ plus-count minus-count))
(p-hat (/ plus-count n)))
(if (or (< n 20) exact?)
(binomial-test-one-sample p-hat n 0.5 :tails tails :exact? t)
(let ((area (- 1 (phi (/ (1- (abs (- plus-count minus-count)))
(sqrt n))))))
(if (eql tails :both)
(* 2 area)
area)))))
(defun sign-test-on-sequences (sequence1 sequence2 &key (exact? nil) (tails :both))
"Same as sign-test, but takes two sequences and tests whether the
entries in one are different (greater or less) than the other."
(test-variables (sequence1 :numseq) (sequence2 :numseq)
("Sequences must be of equal length"
:test (= (length sequence1) (length sequence2))))
(let* ((differences (map 'list #'- sequence1 sequence2))
(plus-count (count #'plusp differences))
(minus-count (count #'minusp differences)))
(sign-test plus-count minus-count :exact? exact? :tails tails)))
;; Rosner 341
(defun wilcoxon-signed-rank-test (differences &optional (tails :both))
"A test on the ranking of positive and negative differences (are the
positive differences significantly larger/smaller than the negative
ones). Assumes a continuous and symmetric distribution of differences,
although not a normal one. This is the normal theory approximation,
which is only valid when N > 15.
This test is completely equivalent to the Mann-Whitney test."
(let* ((nonzero-differences (remove 0 differences :test #'=))
(sorted-list (sort (mapcar (lambda (dif)
(list (abs dif) (sign dif)))
nonzero-differences)
#'<
:key #'first))
(distinct-values (delete-duplicates (mapcar #'first sorted-list)))
(ties nil))
(when (< (length nonzero-differences) 16)
(error "This Wilcoxon Signed-Rank Test (normal approximation method) requires nonzero N > 15"))
(unless (member tails '(:positive :negative :both))
(error "tails must be one of :positive, :negative or :both, not ~a" tails))
; add avg-rank to the sorted values
(dolist (value distinct-values)
(let ((first (position value sorted-list :key #'first))
(last (position value sorted-list :key #'first :from-end t)))
(if (= first last)
(nconc (find value sorted-list :key #'first) (list (1+ first)))
(let ((number-tied (1+ (- last first)))
(avg-rank (1+ (/ (+ first last) 2)))) ; +1 since 0 based
(push number-tied ties)
(dotimes (i number-tied)
(nconc (nth (+ first i) sorted-list) (list avg-rank)))))))
(setq ties (nreverse ties))
(let* ((direction (if (eq tails :negative) -1 1))
(r1 (reduce #'+ (mapcar (lambda (entry)
(if (= (second entry) direction)
(third entry)
0))
sorted-list)))
(n (length nonzero-differences))
(expected-r1 (/ (* n (1+ n)) 4))
(ties-factor (if ties
(/ (reduce #'+ (mapcar (lambda (ti)
(- (* ti ti ti) ti))
ties))
48)
0))
(var-r1 (- (/ (* n (1+ n) (1+ (* 2 n))) 24) ties-factor))
(T-score (/ (- (abs (- r1 expected-r1)) 1/2) (sqrt var-r1))))
(* (if (eq tails :both) 2 1) (- 1 (phi T-score))))))
(defun wilcoxon-signed-rank-test-on-sequences (sequence1 sequence2
&optional (tails :both))
(test-variables (sequence1 :numseq) (sequence2 :numseq)
("Sequences must be of equal length"
:test (= (length sequence1) (length sequence2))))
(wilcoxon-signed-rank-test (map 'list #'- sequence1 sequence2) tails))
;; Rosner 395
(defun chi-square-test-rxc (contingency-table)
"Takes contingency-table, an RxC array, and returns the significance
of the relationship between the row variable and the column variable.
Any difference in proportion will cause this test to be significant --
consider using the test for trend instead if you are looking for a
consistent change."
(let* ((rows (array-dimension contingency-table 0))
(columns (array-dimension contingency-table 1))
(row-marginals (make-array rows :initial-element 0.0))
(column-marginals (make-array columns :initial-element 0.0))
(total 0.0)
(expected-lt-5 0)
(expected-lt-1 0)
(expected-values (make-array (list rows columns)
:element-type 'single-float))
(x2 0.0))
(dotimes (i rows)
(dotimes (j columns)
(let ((cell (aref contingency-table i j)))
(incf (svref row-marginals i) cell)
(incf (svref column-marginals j) cell)
(incf total cell))))
(dotimes (i rows)
(dotimes (j columns)
(let ((expected (/ (* (aref row-marginals i) (aref column-marginals j))
total)))
(when (< expected 1) (incf expected-lt-1))
(when (< expected 5) (incf expected-lt-5))
(setf (aref expected-values i j) expected))))
(when (plusp expected-lt-1)
(error "This test cannot be used when an expected value is less than one"))
(when (> expected-lt-5 (/ (* rows columns) 5))
(error "This test cannot be used when more than 1/5 of the expected values are less than 5."))
(dotimes (i rows)
(dotimes (j columns)
(incf x2 (/ (square (- (aref contingency-table i j)
(aref expected-values i j)))
(aref expected-values i j)))))
(- 1 (chi-square-cdf x2 (* (1- rows) (1- columns))))))
;; Rosner 398
(defun chi-square-test-for-trend (row1-counts row2-counts &optional scores)
"This test works on a 2xk table and assesses if there is an increasing
or decreasing trend. Arguments are equal sized lists counts.
Optionally, provide a list of scores, which represent some numeric
attribute of the group. If not provided, scores are assumed to be 1
to k."
(unless scores (setq scores (dotimes (i (length row1-counts) (nreverse scores))
(push (1+ i) scores))))
(test-variables (row1-counts :posintseq) (row2-counts :posintseq) (scores :numseq)
("Sequences must be of equal length"
:test (= (length row1-counts) (length row2-counts))))
(let* ((ns (map 'list #'+ row1-counts row2-counts))
(p-hats (map 'list #'/ row1-counts ns))
(n (reduce #'+ ns))
(p-bar (/ (reduce #'+ row1-counts) n))
(q-bar (- 1 p-bar))
(s-bar (mean scores))
(a (reduce #'+ (mapcar (lambda (p-hat ni s)
(* ni (- p-hat p-bar) (- s s-bar)))
p-hats ns scores)))
(b (* p-bar q-bar (- (reduce #'+ (mapcar (lambda (ni s) (* ni (square s)))
ns scores))
(/ (square (reduce #'+ (mapcar (lambda (ni s) (* ni s))
ns scores)))
n))))
(x2 (/ (square a) b))
(significance (- 1 (chi-square-cdf (float x2) 1))))
(when (< (* p-bar q-bar n) 5)
(error "This test is only applicable when N * p-bar * q-bar >= 5"))
(format t "~%The trend is ~a, p = ~f"
(if (< a 0) "decreasing" "increasing")
significance)
significance))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Sample size estimates
;;;
;; Rosner 238
(defun t-test-one-sample-sse (mu mu-null variance &key
(alpha 0.05) (1-beta .95) (tails :both))
"Returns the number of subjects needed to test whether the mean of a
normally distributed sample mu is different from a null hypothesis
mean mu-null and variance variance, with alpha, 1-beta and tails as
specified."
(test-variables (mu number) (mu-null number) (variance :posnum)
(alpha :prob) (1-beta :prob))
(let ((z-beta (z 1-beta))
(z-alpha (z (- 1 (if (eql tails :both) (/ alpha 2) alpha)))))
(round-up (/ (* variance (square (+ z-beta z-alpha)))
(square (- mu-null mu))))))
;; Rosner 308
(defun t-test-two-sample-sse (mu1 variance1 mu2 variance2 &key
(sample-ratio 1) (alpha 0.05)
(1-beta .95) (tails :both))
"Returns the number of subjects needed to test whether the mean mu1 of
a normally distributed sample (with variance variance1) is different
from a second sample with mean mu2 and variance variance2, with alpha,
1-beta and tails as specified. It is also possible to set a sample
size ratio of sample 1 to sample 2."
(test-variables (mu1 number) (variance1 :posnum) (mu2 number)
(variance2 :posnum) (sample-ratio :posnum) (alpha :prob)
(1-beta :prob))
(let* ((delta2 (square (- mu1 mu2)))
(z-term (square (+ (z 1-beta)
(z (- 1 (if (eql tails :both)
(/ alpha 2)
alpha))))))
(n1 (round-up (/ (* (+ variance1 (/ variance2 sample-ratio)) z-term)
delta2))))
(values n1 (round-up (* sample-ratio n1)))))
;; Rosner 311
(defun t-test-paired-sse (difference-mu difference-variance
&key (alpha 0.05) (1-beta 0.95)
(tails :both))
"Returns the number of subjects needed to test whether the differences
with mean difference-mu and variance difference-variance, with alpha,
1-beta and tails as specified."
(test-variables (difference-mu number) (difference-variance :posnum)
(alpha :prob) (1-beta :prob))
(round-up (/ (* 2 difference-variance
(square (+ (z 1-beta)
(z (- 1 (if (eql tails :both)
(/ alpha 2)
alpha))))))
(square difference-mu))))
;; Rosner 254
(defun binomial-test-one-sample-sse (p-estimated p-null &key
(alpha 0.05) (1-beta 0.95)
(tails :both))
"Returns the number of subjects needed to test whether an observed
probability is significantly different from a particular binomial null
hypothesis with a significance alpha and a power 1-beta."
(test-variables (p-estimated :prob) (p-null :prob) (alpha :prob) (1-beta :prob))
(let ((q-null (- 1 p-null))
(q-estimated (- 1 p-estimated)))
(round-up
(/ (* p-null q-null
(square (+ (z (- 1 (if (eql tails :both) (/ alpha 2) alpha)))
(* (z 1-beta)
(sqrt (/ (* p-estimated q-estimated)
(* p-null q-null)))))))
(square (- p-estimated p-null))))))
;; Rosner 384
(defun binomial-test-two-sample-sse (p1 p2 &key (alpha 0.05)
(sample-ratio 1)
(1-beta .95) (tails :both))
"The number of subjects needed to test if two binomial probabilities
are different at a given significance alpha and power 1-beta. The
sample sizes can be unequal; the p2 sample is sample-sse-ratio * the
size of the p1 sample. It can be a one tailed or two tailed test."
(test-variables (p1 :prob) (p2 :prob) (alpha :prob) (1-beta :prob)
(sample-ratio :posnum))
(let* ((q1 (- 1 p1))
(q2 (- 1 p2))
(delta (abs (- p1 p2)))
(p-bar (/ (+ p1 (* sample-ratio p2)) (1+ sample-ratio)))
(q-bar (- 1 p-bar))
(z-alpha (z (- 1 (if (eql tails :both) (/ alpha 2) alpha))))
(z-beta (z 1-beta))
(n1 (round-up
(/ (square (+ (* (sqrt (* p-bar q-bar (1+ (/ sample-ratio))))
z-alpha)
(* (sqrt (+ (* p1 q1) (/ (* p2 q2) sample-ratio)))
z-beta)))
(square delta)))))
(values n1 (round-up (* sample-ratio n1)))))
;; Rosner 387
(defun binomial-test-paired-sse (pd pa &key (alpha 0.05)
(1-beta 0.95) (tails :both))
"Sample size estimate for the McNemar (discordant pairs) test. Pd is
the projected proportion of discordant pairs among all pairs, and Pa
is the projected proportion of type A pairs among discordant
pairs. alpha, 1-beta and tails are as binomal-test-two-sample-sse.
Returns the number of individuals necessary; that is twice the number
of matched pairs necessary."
(test-variables (pd :prob) (pa :posnum) (alpha :prob) (1-beta :prob))
(let ((qa (- 1 pa))
(z-alpha (z (- 1 (if (eql tails :both) (/ alpha 2) alpha))))
(z-beta (z 1-beta)))
(round-up (/ (square (+ z-alpha (* 2 z-beta (sqrt (* pa qa)))))
(* 2 (square (- pa 1/2)) pd)))))
;; Rosner 463
(defun correlation-sse (rho &key (alpha 0.05) (1-beta 0.95))
"Returns the size of a sample necessary to find a correlation of
expected value rho with significance alpha and power 1-beta."
(test-variables (rho :prob) (alpha :prob) (1-beta :prob))
(round-up (+ 3 (/ (square (+ (z (- 1 alpha)) (z 1-beta)))
(square (fisher-z-transform rho))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Correlation and Regression
;;;
;; Rosner 431, 441 for t-test
(defun linear-regression (points)
"Computes the regression equation for a least squares fit of a line to
a sequence of points (each a list of two numbers, e.g. '((1.0
0.1) (2.0 0.2))) and report the intercept, slope, correlation
coefficient r, R^2, and the significance of the difference of the
slope from 0."
(test-variables (points sequence))
(let ((xs (map 'list #'first points))
(ys (map 'list #'second points)))
(test-variables (xs :numseq) (ys :numseq))
(let* ((x-bar (mean xs))
(y-bar (mean ys))
(n (length points))
(Lxx (reduce #'+ (mapcar (lambda (xi) (square (- xi x-bar))) xs)))
(Lyy (reduce #'+ (mapcar (lambda (yi) (square (- yi y-bar))) ys)))
(Lxy (reduce #'+ (mapcar (lambda (xi yi) (* (- xi x-bar) (- yi y-bar)))
xs ys)))
(b (/ Lxy Lxx))
(a (- y-bar (* b x-bar)))
(reg-ss (* b Lxy))
(res-ms (/ (- Lyy reg-ss) (- n 2)))
(r (/ Lxy (sqrt (* Lxx Lyy))))
(r2 (/ reg-ss Lyy))
(t-test (/ b (sqrt (/ res-ms Lxx))))
(t-significance (t-significance t-test (- n 2) :tails :both)))
(format t "~%Intercept = ~f, slope = ~f, r = ~f, R^2 = ~f, p = ~f"
a b r r2 t-significance)
(values a b r r2 t-significance))))
(defun correlation-coefficient (points)
"just r from linear-regression. Also called Pearson Correlation"
(test-variables (points sequence))
(let ((xs (map 'list #'first points))
(ys (map 'list #'second points)))
(test-variables (xs :numseq) (ys :numseq))
(let ((x-bar (mean xs))
(y-bar (mean ys)))
(/ (reduce #'+ (mapcar (lambda (xi yi) (* (- xi x-bar) (- yi y-bar)))
xs ys))
(sqrt (* (reduce #'+ (mapcar (lambda (xi) (square (- xi x-bar)))
xs))
(reduce #'+ (mapcar (lambda (yi) (square (- yi y-bar)))
ys))))))))
;; Rosner 464
(defun correlation-test-two-sample (r1 n1 r2 n2 &key (tails :both))
"Test if two correlation coefficients are different. Users Fisher's Z
test."
(test-variables (r1 :prob) (n1 :posint) (r2 :prob) (n2 :posint))
(let* ((z1 (fisher-z-transform r1))
(z2 (fisher-z-transform r2))
(lambda (/ (- z1 z2) (sqrt (+ (/ (- n1 3)) (/ (- n2 3)))))))
(ecase tails
(:both (* 2 (if (<= lambda 0) (phi lambda) (- 1 (phi lambda)))))
(:positive (- 1 (phi lambda)))
(:negative (phi lambda)))))
(defun correlation-test-two-sample-on-sequences (points1 points2 &key (tails :both))
(test-variables (points1 sequence) (points2 sequence))
(let ((r1 (correlation-coefficient points1))
(n1 (length points1))
(r2 (correlation-coefficient points2))
(n2 (length points2)))
(correlation-test-two-sample r1 n1 r2 n2 :tails tails)))
;; Rosner 498
(defun spearman-rank-correlation (points)
"Spearman rank correlation computes the relationship between a pair of
variables when one or both are either ordinal or have a distribution
that is far from normal. It takes a list of points (same format as
linear-regression) and returns the spearman rank correlation
coefficient and its significance."
(test-variables (points sequence))
(let ((xis (mapcar #'first points))
(yis (mapcar #'second points)))
(test-variables (xis :numseq) (yis :numseq))
(let* ((n (length points))
(sorted-xis (sort (copy-seq xis) #'<))
(sorted-yis (sort (copy-seq yis) #'<))
(average-x-ranks (mapcar (lambda (x) (average-rank x sorted-xis)) xis))
(average-y-ranks (mapcar (lambda (y) (average-rank y sorted-yis)) yis))
(mean-x-rank (mean average-x-ranks))
(mean-y-rank (mean average-y-ranks))
(Lxx (reduce #'+ (mapcar (lambda (xi-rank) (square (- xi-rank mean-x-rank)))
average-x-ranks)))
(Lyy (reduce #'+ (mapcar (lambda (yi-rank) (square (- yi-rank mean-y-rank)))
average-y-ranks)))
(Lxy (reduce #'+ (mapcar (lambda (xi-rank yi-rank)
(* (- xi-rank mean-x-rank)
(- yi-rank mean-y-rank)))
average-x-ranks average-y-ranks)))
(rs (/ Lxy (sqrt (* Lxx Lyy))))
(ts (/ (* rs (sqrt (- n 2))) (sqrt (- 1 (square rs)))))
(p (t-significance ts (- n 2) :tails :both)))
(format t "~%Spearman correlation coefficient ~f, p = ~f" rs p)
(values rs p))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Significance functions
;;;
(defun t-significance (t-statistic dof &key (tails :both))
"Lookup table in Rosner; this is adopted from CLASP/Numeric
Recipes (CLASP 1.4.3), http://eksl-www.cs.umass.edu/clasp.html"
(test-variables (t-statistic number) (dof :posint))
(setf dof (float dof t-statistic))
(let ((a (beta-incomplete (* 0.5 dof) 0.5 (/ dof (+ dof (square t-statistic))))))
;; A is 2*Integral from (abs t-statistic) to Infinity of t-distribution
(ecase tails
(:both a)
(:positive (if (plusp t-statistic)
(* .5 a)
(- 1.0 (* .5 a))))
(:negative (if (plusp t-statistic)
(- 1.0 (* .5 a))
(* .5 a))))))
(defun f-significance
(f-statistic numerator-dof denominator-dof &optional one-tailed-p)
"Adopted from CLASP, but changed to handle F < 1 correctly in the
one-tailed case. The `f-statistic' must be a positive number. The
degrees of freedom arguments must be positive integers. The
`one-tailed-p' argument is treated as a boolean.
This implementation follows Numerical Recipes in C, section 6.3 and
the `ftest' function in section 13.4."
(setq f-statistic (float f-statistic))
(test-variables (f-statistic :posnum) (numerator-dof :posint) (denominator-dof :posint))
(let ((tail-area (beta-incomplete
(* 0.5d0 denominator-dof)
(* 0.5d0 numerator-dof)
(float (/ denominator-dof
(+ denominator-dof
(* numerator-dof f-statistic))) 1d0))))
(if one-tailed-p
(if (< f-statistic 1) (- 1 tail-area) tail-area)
(progn (setf tail-area (* 2.0 tail-area))
(if (> tail-area 1.0)
(- 2.0 tail-area)
tail-area)))))
;; CHI-SQUARE and NORMAL (Gaussian) significance are calculated from their
;; respective CDF functions.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Utilities of potential external use
;;;
(defun random-sample (n sequence)
"Return a random sample of size N from sequence, without replacement.
If N is equal to or greater than the length of the sequence, return
the entire sequence."
(test-variables (n integer) (sequence sequence))
(cond ((null sequence) nil)
((<= n 0) nil)
((< (length sequence) n) sequence)
(t (let ((one (random-pick sequence)))
(cons one (random-sample (1- n) (remove one sequence :count 1)))))))
(defun random-pick (sequence)
"Random selection from sequence"
(test-variables (sequence sequence))
(when sequence (elt sequence (random (length sequence)))))
(defun random-normal (&key (mean 0) (sd 1))
"returns a random number with mean and standard-distribution as
specified."
(test-variables (mean number) (sd :posnum))
(let ((random-standard (z (random 1d0))))
(+ mean (* sd random-standard))))
(defun bin-and-count (sequence n)
"Make N equal width bins and count the number of elements of sequence
that belong in each."
(let* ((min (reduce #'min sequence))
(increment (/ (- (reduce #'max sequence) min) n))
(bins (make-array n :initial-element 0)))
(dotimes (bin n bins)
(setf (aref bins bin)
(count-if (lambda (x) (and (>= x (+ min (* bin increment)))
(< x (+ min (* (1+ bin) increment)))))
sequence)))))
;; Rosner 458
(defun fisher-z-transform (r)
"Transforms the correlation coefficient to an approximately normal
distribution."
(test-variables (r :prob))
(* 1/2 (log (/ (1+ r) (- 1 r)))))
;; Rosner 88
(defun permutations (n k)
"How many ways to take n things taken k at a time, when order
matters"
(test-variables (n :posint) (k :posint)
("K must be less than or equal to N" :test (<= k n)))
(let ((p 1))
(dotimes (i (1+ k) p)
(setq p (* p (- n i))))))
;; Rosner 90
(defun choose (n k)
"How may ways to take n things taken k at a time, when order doesn't
matter"
(test-variables (n :posint)
("K must be between 0 and N (inclusive)" :test (and (>= k 0) (<= k n))))
(/ (factorial n) (* (factorial k) (factorial (- n k)))))
(defun mean-sd-n (sequence)
"A combined calculation that is often useful. Takes a sequence and
returns three values: mean, standard deviation and N."
(test-variables (sequence :numseq))
(values (mean sequence) (standard-deviation sequence) (length sequence)))
(defun round-float (x &key (precision 5))
"Rounds a floating point number to a specified number of digits
precision."
(test-variables (x number) (precision :posint))
(/ (round x (expt 10 (- precision))) (expt 10 precision)))
(defun false-discovery-correction (p-values &key (rate 0.05))
"A multiple testing correction that is less conservative than Bonferroni.
Takes a list of p-values and a false discovery rate, and returns the
number of p-values that are likely to be good enough to reject the
null at that rate. Returns a second value which is the p-value
cutoff. See
Benjamini Y and Hochberg Y. \"Controlling the false discovery rate:
a practical and powerful approach to multiple testing.\" J R Stat
Soc Ser B 57: 289 300, 1995."
(let ((number-of-tests (length p-values))
(sorted-p-values (sort p-values #'>)))
(do ((p-value (pop sorted-p-values) (pop sorted-p-values))
(tests-to-go number-of-tests (1- tests-to-go)))
((or (null p-value)
(<= p-value (* rate (/ tests-to-go number-of-tests))))
(values tests-to-go (* rate (/ tests-to-go number-of-tests)))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Internal functions
;;;
(defun round-up (x)
(multiple-value-bind (rounded ignore) (ceiling x)
(declare (ignore ignore))
rounded))
(defun sign (x)
(cond ((minusp x) -1)
((plusp x) 1)
((zerop x) 0)
(t nil)))
(defun factorial (number)
(if (not (and (integerp number) (>= number 0)))
(error "factorial: ~a is not a positive integer" number)
(labels ((fact (num) (if (= 0 num) 1 (* num (fact (1- num))))))
(fact number))))
(defun average-rank (value sorted-values)
"Average rank calculation for non-parametric tests. Ranks are 1
based, but lisp is 0 based, so add 1!"
(let ((first (position value sorted-values))
(last (position value sorted-values :from-end t)))
(1+ (if (= first last)
first
(/ (+ first last) 2)))))
;;; CLASP utilities:
;;; Copyright (c) 1990 - 1994 University of Massachusetts
;;; Department of Computer Science
;;; Experimental Knowledge Systems Laboratory
;;; Professor Paul Cohen, Director.
;;; All rights reserved.
;;; Permission to use, copy, modify and distribute this software and its
;;; documentation is hereby granted without fee, provided that the above
;;; copyright notice of EKSL, this paragraph and the one following appear
;;; in all copies and in supporting documentation.
;;; EKSL makes no representation about the suitability of this software for any
;;; purposes. It is provided "AS IS", without express or implied warranties
;;; including (but not limited to) all implied warranties of merchantability
;;; and fitness for a particular purpose, and notwithstanding any other
;;; provision contained herein. In no event shall EKSL be liable for any
;;; special, indirect or consequential damages whatsoever resulting from loss
;;; of use, data or profits, whether in an action of contract, negligence or
;;; other tortuous action, arising out of or in connection with the use or
;;; performance of this software, even if EKSL is advised of the possiblity of
;;; such damages.
;;; For more information write to [email protected]
(defun error-function (x)
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(let ((erf (gamma-incomplete .5 (square x))))
(if (>= x 0.0) erf (- erf))))
(defun gamma-incomplete (a x)
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(declare (optimize (safety 3)))
(setq a (coerce a 'double-float))
(let ((gln (the double-float (gamma-ln a))))
(when (= x 0.0)
(return-from gamma-incomplete (values 0.0d0 gln)))
(if (< x (+ a 1.0d0))
;; Use series representation. The following is the code of what
;; Numerical Recipes in C calls ``GSER'
(let* ((itmax 1000)
(eps 3.0d-7)
(ap a)
(sum (/ 1d0 a))
(del sum))
(declare (type double-float ap sum del))
(dotimes (i itmax)
(incf ap 1.0d0)
(setf del (* del (/ x ap)))
(incf sum del)
(if (< (abs del) (* eps (abs sum)))
(let ((result (underflow-goes-to-zero
(* sum (safe-exp (- (* a (log x)) x gln))))))
(return-from gamma-incomplete (values result gln)))))
(error "Series didn't converge:~%~
Either a=~s is too large, or ITMAX=~d is too small." a itmax))
;; Use the continued fraction representation. The following is the
;; code of what Numerical Recipes in C calls ``GCF.'' Their code
;; computes the complement of the desired result, so we subtract from
;; 1.0 at the end.
(let ((itmax 1000)
(eps 3.0e-7)
(gold 0d0) (g 0d0) (fac 1d0) (b1 1d0) (b0 0d0)
(anf 0d0) (ana 0d0) (an 0d0) (a1 x) (a0 1d0))
(declare (type double-float gold g fac b1 b0 anf ana an a1 a0))
(dotimes (i itmax)
(setf an (coerce (1+ i) 'double-float)
ana (- an a)
a0 (* fac (+ a1 (* a0 ana)))
b0 (* fac (+ b1 (* b0 ana)))
anf (* fac an)
a1 (+ (* x a0) (* anf a1))
b1 (+ (* x b0) (* anf b1)))
(unless (zerop a1)
(setf fac (/ 1.0d0 a1)
g (* b1 fac))
(if (< (abs (/ (- g gold) g)) eps)
(let ((result (underflow-goes-to-zero
(* (safe-exp (- (* a (log x)) x gln)) g))))
(return-from
gamma-incomplete (values (- 1.0 result) gln)))
(setf gold g))))
(error "Continued Fraction didn't converge:~%~
Either a=~s is too large, or ITMAX=~d is too small." a
itmax)))))
(defun gamma-ln (x)
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(cond ((<= x 0) (error "arg to gamma-ln must be positive: ~s" x))
((> x 1.0d302)
(error "Argument too large: ~e" x))
((= x 0.5d0)
;; special case for this arg, since it is used by the error-function
(log (sqrt pi)))
((< x 1)
;; Use reflection formula: Gamma(1-z) = z*pi/(Gamma(1+z)sin(pi*z))
(let ((z (- 1.0d0 x)))
(- (+ (log z) (log pi)) (+ (gamma-ln (+ 1.0 z)) (log (sin (* pi z)))))))
(t (let* ((xx (- x 1.0d0))
(tmp (+ xx 5.5d0))
(ser 1.0d0))
(declare (type double-float xx tmp ser))
(decf tmp (* (+ xx 0.5d0) (log tmp)))
(dolist (coef '(76.18009173d0 -86.50532033d0 24.01409822d0
-1.231739516d0 0.120858003d-2 -0.536382d-5))
(declare (type double-float coef))
(incf xx 1.0d0)
(incf ser (/ coef xx)))
(- (log (* 2.50662827465d0 ser)) tmp)))))
(defun error-function-complement (x)
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(let* ((z (abs x))
(y (/ 1d0 (+ 1d0 (* 0.5 z)))) ; instead of t
(ans
(* y (exp (+ (* (- z) z)
-1.26551223
(* y
(+ 1.00002368
(* y
(+ 0.37409196
(* y
(+ 0.09678418
(* y
(+ -0.18628806
(* y
(+ 0.27886807
(* y
(+ -1.13520398
(* y
(+ 1.48851587
(* y
(+ -0.82215223
(* y 0.17087277))))))))))))))))))))))
(declare (type double-float z y ans))
(if (>= x 0.0)
ans
(- 2.0 ans))))
(defun find-critical-value
(p-function p-value &optional (x-tolerance .00001) (y-tolerance .00001))
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(let* ((x-low 0d0)
(fx-low 1d0)
(x-high 1d0)
(fx-high (coerce (funcall p-function x-high) 'double-float)))
;; double up
(declare (type double-float x-low fx-low x-high fx-high))
(do () (nil)
;; for general functions, we'd have to try the other way of bracketing,
;; and probably have another way to terminate if, say, y is not in the
;; range of f.
(when (>= fx-low p-value fx-high)
(return))
(setf x-low x-high
fx-low fx-high
x-high (* 2.0 x-high)
fx-high (funcall p-function x-high)))
;; binary search
(do () (nil)
(let* ((x-mid (/ (+ x-low x-high) 2.0))
(fx-mid (funcall p-function x-mid))
(y-diff (abs (- fx-mid p-value)))
(x-diff (- x-high x-low)))
(when (or (< x-diff x-tolerance)
(< y-diff y-tolerance))
(return-from find-critical-value x-mid))
;; Because significance is monotonically decreasing with x, if the
;; function is above the desired p-value...
(if (< p-value fx-mid)
;; then the critical x is in the upper half
(setf x-low x-mid
fx-low fx-mid)
;; otherwise, it's in the lower half
(setf x-high x-mid
fx-high fx-mid))))))
(defun beta-incomplete (a b x)
"Adopted from CLASP 1.4.3, http://eksl-www.cs.umass.edu/clasp.html"
(flet ((betacf (a b x)
;; straight from Numerical Recipes in C, section 6.3
(declare (type double-float a b x))
(let ((ITMAX 1000)
(EPS 3.0d-7)
(qap 0d0) (qam 0d0) (qab 0d0) (em 0d0) (tem 0d0) (d 0d0)
(bz 0d0) (bm 1d0) (bp 0d0) (bpp 0d0)
(az 1d0) (am 1d0) (ap 0d0) (app 0d0) (aold 0d0))
(declare (type double-float qap qam qab em tem d
bz bm bp bpp az am ap app aold))
(setf qab (+ a b)
qap (+ a 1d0)
qam (- a 1d0)
bz (- 1d0 (/ (* qab x) qap)))
(dotimes (m ITMAX)
(setf em (coerce (1+ m) 'double-float)
tem (+ em em)
d (/ (* em (- b em) x)
(* (+ qam tem) (+ a tem)))
ap (+ az (* d am))
bp (+ bz (* d bm))
d (/ (* (- (+ a em)) (+ qab em) x)
(* (+ qap tem) (+ a tem)))
app (+ ap (* d az))
bpp (+ bp (* d bz))
aold az
am (/ ap bpp)
bm (/ bp bpp)
az (/ app bpp)
bz 1d0)
(if (< (abs (- az aold)) (* EPS (abs az)))
(return-from betacf az)))
(error "a=~s or b=~s too big, or ITMAX too small in BETACF"
a b))))
(declare (notinline betacf))
(setq a (coerce a 'double-float) b (coerce b 'double-float)
x (coerce x 'double-float))
(when (or (< x 0d0) (> x 1d0))
(error "x must be between 0d0 and 1d0: ~f" x))
;; bt is the factors in front of the continued fraction
(let ((bt (if (or (= x 0d0) (= x 1d0))
0d0
(exp (+ (gamma-ln (+ a b))
(- (gamma-ln a))
(- (gamma-ln b))
(* a (log x))
(* b (log (- 1d0 x))))))))
(if (< x (/ (+ a 1d0) (+ a b 2.0)))
;; use continued fraction directly
(/ (* bt (betacf a b x)) a)
;; use continued fraction after making the symmetry transformation
(- 1d0 (/ (* bt (betacf b a (- 1d0 x))) b))))))
(defun safe-exp (x)
"Eliminates floating point underflow for the exponential function.
Instead, it just returns 0.0d0"
(setf x (coerce x 'double-float))
(if (< x (log least-positive-double-float))
0.0d0
(exp x)))
;;; ---------------------- Added hereafter by Jeff Shrager ----------------------
;;; Jeff Shrager's General Lisp Numerical Utilities
(defmacro display (&rest l)
`(progn ,@(loop for i in l
collect `(format t "~a = ~a~%" ',i ,i))))
;;; --- Various math and stats routines.
(defun pround (n v)
"Returns a string that is rounded to the appropriate number of
digits, but the only thing you can do with it is print it. It's just
a convenience hack for rounding recursive lists."
(if (listp v)
(mapcar (lambda (v) (pround n v)) v)
(if (numberp v)
(format nil (format nil "~~,~af" n) v)
v)))
;;; And some conveniences:
(defun p2 (v) (pround 2 v))
(defun t1-test (values target &optional (warn? t))
"One way t-test to see if a group differs from a numerical mean
target value. From Misanin & Hinderliter p. 248."
(let ((t1-value (t1-value values target)))
(values t1-value
(t-p-value (abs t1-value) (1- (length values)) warn?))))
(defun t1-value (values target)
(/ (- (mean values) target)
(/ (standard-deviation values)
(sqrt (length values)))))
(defun n-random (n l &aux r)
"Select n random sublists from a list, without replacement. This
copies the list and then destroys the copy. N better be less than or
equal to (length l)."
(setq l (copy-list l))
(dotimes (k n)
(if (null (cdr l)) ; this has to be the last one
(progn (push (car l) r)
(return nil))
;; If we're taking the first, it's easy, otherwise
;; the first item get shoved into the middle.
(let ((take (random (length l))))
(if (zerop take)
(push (car l) r)
(let ((nc (nthcdr take l)))
(push (car nc) r)
(rplaca nc (car l))))
(pop l))))
r)
(defun t2-test (l1 l2)
"T2-test calculates an UNPAIRED t-test.
From Misanin & Hinderliter p. 268. The t-cdf part is inherent in
xlispstat, and I'm not entirely sure that it's really the right
computation since it doens't agree entirely with Table 5 of M&H, but
it's close, so I assume that M&H have round-off error."
(if (or (equal l1 l2) ; protect against 0 result from sdiff!
(null (cdr l1)) ; and other stupidity!
(null (cdr l2)))
(values "n/a" "n/a")
(let ((tval (t2-value l1 l2)))
(values tval (t-p-value (abs tval) (- (+ (length l1) (length l2)) 2))))))
(defun t2-value (l1 l2)
(let* ((n1 (float (length l1)))
(n2 (float (length l2)))
(s21 (s2 l1 n1))
(s22 (s2 l2 n2))
(m1 (mean l1))
(m2 (mean l2))
(s2p (/ (+ (* s21 (1- n1))
(* s22 (1- n2)))
(+ (1- n1) (1- n2))))
)
(/ (- m1 m2)
(sqrt (+ (/ s2p n1) (/ s2p n2))))))
(defun s2 (l n)
(/ (- (sum (mapcar (lambda (a) (* a a)) l))
(/ (let ((r (sum l))) (* r r)) n))
(1- n)))
;;; For non-xlispstat, we compute t-cdf the hard way. Sometime I
;;; ought to put in a real computation, but for the moment, it's a
;;; total cheat, just returning the symbol '>.05 or '<.05. Each
;;; Entry is a df followed by the critical point at that df.
(defvar *t-cdf-critical-points-table-for-.05*
'((1 . 6.31)
(2 . 2.92)
(3 . 2.35)
(4 . 2.13)
(5 . 2.02)
(6 . 1.94)
(7 . 1.89)
(8 . 1.86)
(9 . 1.83)
(10 . 1.81)
(15 . 1.75)
(20 . 1.72)
(25 . 1.71)
(30 . 1.70)
(40 . 1.68)
(60 . 1.67)
(120 . 1.66)))
(defun t-p-value (x df &optional (warn? t))
(if (> df 120)
(progn
(if warn?
(format t "Warning df (~a) is off the scale. Using df=120~%" df))
(setq df 120)))
(dolist (tcp *t-cdf-critical-points-table-for-.05*)
(if (or (= df (car tcp))
(< df (car tcp)))
(return (if (> x (cdr tcp)) '*/p<.05! nil)))))
;;; --- This emulates some of the xlispstat functions, and other stats
;;; utilities.
;;; Some math ops that take many args.
(defun sum (l &aux (sum 0))
(dolist (n l) (incf sum n)) sum)
(defun sqr (a)
(if (numberp a) (expt a 2)
(mapcar #'* a a)))
;;; This version of min and max operate on a list if there's only one arg.
(defun max* (l &rest ll &aux m)
(if ll (setq l (cons l ll)))
(setq m (pop l))
(dolist (i l)
(if (> i m) (setq m i)))
m)
(defun min* (l &rest ll &aux m)
(if ll (setq l (cons l ll)))
(setq m (pop l))
(dolist (i l)
(if (< i m) (setq m i)))
m)
;;; Warning, you can't use apply on most of the math operations
;;; because the arglist limits a too small for any large list.
;;; LH's version is better?
#+superseded
(defun mean (l)
(/ (sum l) (float (length l))))
(defun protected-mean (l)
"Computes a mean protected where there will be a divide by zero, and
gives us n/a in that case."
(loop with sum = 0
with n = 0
as value in l
when (numberp value)
do (incf sum value) (incf n)
finally (return (cond ((not (zerop n)) (/ sum (float n)))
(t 'n/a)))))
#+superseded ; LH's version is better?
(defun standard-deviation (l)
"This is specially protected for zero divisors."
(if (null (cdr l))
0.0
(sqrt
(let ((m (mean l)))
(* (/ 1.0 (1- (length l)))
(sum (mapcar (lambda (x) (expt (- x m) 2)) l)))))))
#+superseded ; LH's version is better?
(defun standard-error (l)
(/ (standard-deviation l) (sqrt (length l))))
(defun lmean (ll)
"Lmean takes the mean of entries in a list of lists vertically.
So: (lmean '((1 2) (5 6))) -> (3 4) The args have to be the same
length."
(let* ((n (length ll))
(sums (copy-list (pop ll))) ; copy so that incf doesn't wreck us!
(len (length sums)))
(dolist (l ll)
(dotimes (k len)
(incf (nth k sums) (nth k l))
))
(setq n (float n))
(mapcar (lambda (v) (/ v n)) sums)))
(defun anova2 (a1b1 a1b2 a2b1 a2b2)
"Two-Way Anova. (From Misanin & Hinderliter, 1991, p. 367-) This is
specialized for four groups of equal n, called by their plot location
names: left1 left2 right1 right2."
(let* ((n (length a1b1)) ; All are the same, so any will do here.
(npq (* 4 n)) ; This is specialized for a 2x2 design; always 4 levels.
(a1 (append a1b1 a1b2))
(suma1 (sum a1))
(a2 (append a2b1 a2b2))
(suma2 (sum a2))
(b1 (append a1b1 a2b1))
(sumb1 (sum b1))
(b2 (append a1b2 a2b2))
(sumb2 (sum b2))
(allscores (append a1 a2))
(sym1 (float (/ (sqr (sum allscores)) npq)))
(sym2 (float (sum (sqr allscores))))
(np (* n 2))
(sym3 (float (/ (+ (sqr suma1) (sqr suma2)) np)))
;(nq np) ; Apparently never used???
(sym4 (float (/ (+ (sqr sumb1) (sqr sumb2)) np)))
(sym5 (float (/ (+ (sqr (sum a1b1)) (sqr (sum a2b1))
(sqr (sum a1b2)) (sqr (sum a2b2)))
n)
))
(ssbg (- sym5 sym1))
(ssa (- sym3 sym1))
(ssb (- sym4 sym1))
(ssab (+ sym1 (- (- sym5 sym4) sym3)))
(sswg (- sym2 sym5))
(sstot (- sym2 sym1))
(df1 3)
(df2 1)
(df3 1)
(df4 1)
(df5 (* 4 (1- n)))
(dftot (1- npq))
(msbg (float (/ ssbg df1)))
(msa (float (/ ssa df2)))
(msb (float (/ ssb df3)))
(msab (float (/ ssab df4)))
(mswg (float (/ sswg df5))))
(list :ssbg ssbg :dfbg df1 :msbg msbg :fbg (/ msbg mswg)
:ssa ssa :dfa df2 :msa msa :fa (/ msa mswg)
:ssb ssb :dfb df3 :msb msb :fb (/ msb mswg)
:ssab ssab :dfab df4 :msab msab :fab (/ msab mswg)
:sswg sswg :dfwg df5 :mswg mswg
:sstot sstot :dftot dftot
:a1b1 a1b1 :a1b2 a1b2 :a2b1 a2b1 :a2b2 a2b2)))
(defun all-squares (as bs &aux squares)
(dolist (a as)
(dolist (b bs)
(push (sqr (* a b)) squares))))
(defun testanova2 ()
(let ((a1b1 '(1 2 3 4 5))
(a1b2 '(3 4 5 6 7))
(a2b1 '(5 6 7 8 9))
(a2b2 '(4 5 6 7 8)))
(anova2 a1b1 a1b2 a2b1 a2b2)))
#| From VassarStats:
(In the above, A are rows, B are cols)
--------------------------------------------------------------------------------
ANOVA SUMMARY
Source SS df MS F P
bg 43.75 3
rows 31.25 1 31.25 12.5 0.002749
columns 1.25 1 1.25 0.5 0.489672
r x c 11.25 1 11.25 4.5 0.049865
wg 40 16 2.5
Total 83.75 19
(bg = between groups; wg = within groups (error))
Results are summarised in ANOVA summary table:
Source Sum of Squares Df Mean Squares F-ratio p
Age 11.25 1 11.25 37.5 .000
Sex 101.25 1 101.25 337.5 .000
Age * sex 1.25 1 1.25 4.167 .058
Error 4.8 16 .3
Total 118.55 20
1. SS for factors and total calculated by formula
2. SS (error) = SS (total), ' SS (factors): 118.55 ' 11.25 ' 101.25 ' 1.25 = 4.8
3. Df calculated from N and number of conditions
4. MS calculated: SS / DF (for each factor)
Age: 11.25 / 1 = 11.25
Sex: 101.25 / 1 = 101.25
Interaction Age * Sex (not notation): 1.25 /1 = 1.25
Error: 4.8 / 16 = 0.3
5. F ratio calculated: MS (factor) / MS (error)
Age: 11.25 / 0.3 = 37.5
Sex: 101.25 / 0.3 = 337.5
Interaction Age * Sex: 1.25 / 0.3 = 4.167
How to report:
Main effect of Age: F(1,16) = 37.5, p < 0.0001
Main effect of Sex: F(1,16) = 337.5, p < 0.0001
Interaction between Age and Sex (or: Age x Sex interaction): F(1,16) = 4.167, p = 0.058
|#
(defun anova2r (g1 g2)
"Two way ANOVA with repeated measures on one dimension. From
Ferguson & Takane, 1989, p. 359. Data is organized differently for
this test. Each group (g1 g2) contains list of all subjects' repeated
measures, and same for B. So, A: ((t1s1g1 t2s1g1 ...) (t1s2g2 t2s2g2
...) ...) Have to have the same number of test repeats for each
subject, and this assumes the same number of subject in each group."
(let* ((c (length (car g1)))
(r 2) ; only two groups in this special case
(tsr1 (mapcar #'sum g1))
(t1 (sum tsr1))
(t1c (let (temp)
(dotimes (n c temp)
(push (sum (mapcar (lambda (s) (nth n s)) g1)) temp))))
(tsr2 (mapcar #'sum g2))
(t2 (sum tsr2))
(t2c (let (temp)
(dotimes (n c temp)
(push (sum (mapcar (lambda (s) (nth n s)) g2)) temp))))
(tc (mapcar #'+ t1c t2c))
(total (+ t1 t2))
(n (length g1))
(q1 (* (/ 1.0 c) (sum (append (sqr tsr1) (sqr tsr2)))))
(q2 (* (/ 1.0 (* c n)) (+ (sqr t1) (sqr t2))))
(q3 (* (/ 1.0 (* 2 n)) (sum (sqr tc))))
(q4 (* (/ 1.0 n) (sum (append (sqr t1c) (sqr t2c)))))
(q5 (sum (append (mapcar #'sum (mapcar #'sqr g1))
(mapcar #'sum (mapcar #'sqr g2)))))
(q6 (/ (sqr total) (* n 2.0 c)))
(ssbs (- q1 q6))
(ssr (- q2 q6))
(sssr (- q1 q2))
(ssws (- q5 q1))
(ssc (- q3 q6))
(ssrc (+ q6 (- (- q4 q2) q3)))
(sscsr (+ q2 (- (- q5 q1) q4)))
(sstotal (- q5 q6))
(dfr (1- r))
(dfc (1- c))
(dfrc (* (1- r) (1- c)))
(dfsr (* r (1- n)))
(dfcsr (* r (1- n) (1- c)))
(msr (/ ssr dfr))
(mssr (/ sssr dfsr))
(msc (/ ssc dfc))
(msrc (/ ssrc dfrc))
(mscsr (/ sscsr dfcsr))
(dftotal (+ dfr dfc dfrc dfsr dfcsr))
(fr (/ msr mssr))
(fc (/ msc mscsr))
(frc (/ ssrc mscsr)))
(if (not (= (length g1) (length g2)))
(format t "Warning, ANOVA2R design has unbalanced cells!~%"))
(list :ssbs ssbs :ssr ssr :sssr sssr :ssws ssws :ssc ssc
:ssrc ssrc :sscsr sscsr :sstotal sstotal
:dfr dfr :dfsr dfsr :dfc dfc :dfrc dfrc :dfcsr dfcsr :dftotal dftotal
:msr msr :mssr mssr :msc msc :msrc msrc :mscsr mscsr
:fr fr :fc fc :frc frc)))
#+example-data
(setq an2rd1 '((2 7 6 7 9)
(4 3 7 12 14)
(7 6 4 12 10)
(1 3 3 6 6)))
#+example-data
(setq an2rd2 '((4 4 7 9 1)
(10 12 12 12 16)
(8 7 8 12 10)
(5 7 6 7 8)))
;;; Example from Neter p.677
#+example-data
(setq neter677data
'((11 17 16 14 15) (12 10 15 19 11) (23 20 18 17) (27 33 22 26 28)))
(defun anova1 (d) ; Note that dots are replaced by dashes, so: Y.. = Y-- here
"One way simple ANOVA, from Neter, et al. p677+. Data is give as a
list of lists, each one representing a treatment, and each containing
the observations."
(let* ((meanYi- (mapcar #'mean d))
(serrYi- (mapcar #'standard-error d))
(r (length d))
(Yi- (mapcar #'sum d))
(ni (mapcar #'length d))
(Y-- (sum Yi-))
(meanY-- (mean meanYi-))
(ntotal (sum ni))
(SSTO (sum (mapcar (lambda (treatment)
(sum (mapcar (lambda (Oij)
(expt (- Oij meanY--) 2)) treatment))) d)))
(SSE (sum (mapcar (lambda (treatment meanYi-)
(sum (mapcar (lambda (Oij)
(expt (- Oij meanYi-) 2)) treatment))) d meanYi-)))
(SSTR (sum (mapcar (lambda (meanYi- ni) (* ni (expt (- meanYi- meanY--) 2))) meanYi- ni)))
(SSTRdf (- r 1))
(SSEdf (- ntotal r))
(SSTOdf (- ntotal 1))
(MSTR (/ SSTR SSTRdf))
(MSE (/ SSE SSedf))
(F* (/ MSTR MSE)))
(list :SUMMARY (format nil "F(.95,~a,~a) = ~a" SSTRdf SSEdf F*)
:r r
:meanYi- meanYi-
:serrYi- serrYi-
:Yi- Yi-
:ni ni
:Y-- Y--
:meanY-- meanY--
:ntotal ntotal
:SSTO SSTO
:SSE SSE
:SSTR SSTR
:SSTRdf SSTRdf
:SSEdf SSEdf
:SSTOdf SSTOdf
:MSTR MSTR
:MSE MSE
:F* F*)))
;;; Q-table for tukey HSD. These are upside down because we
;;; want to walk them backwards to find the stopping point.
(defvar *q-table*
'(
(5 ; K=5
; DF 0.05 0.01
(90 3.94 4.76)
(60 3.98 4.82)
(50 4.00 4.87)
(40 4.04 4.93)
(35 4.06 4.98)
(30 4.10 5.05)
(27 4.13 5.10)
(24 4.17 5.17)
(22 4.19 5.22)
(20 4.23 5.29)
(19 4.25 5.33)
(18 4.28 5.38)
(17 4.30 5.43)
(16 4.33 5.49)
(15 4.37 5.56)
(14 4.41 5.63)
(13 4.45 5.73)
(12 4.51 5.84)
(11 4.57 5.97)
(10 4.65 6.14)
(9 4.76 6.35))
(4 ; K=4
; DF 0.05 0.01
(90 3.70 4.54)
(60 3.74 4.59)
(50 3.76 4.63)
(40 3.79 4.70)
(35 3.81 4.74)
(30 3.85 4.80)
(27 3.87 4.85)
(24 3.90 4.91)
(22 3.92 4.96)
(20 3.96 5.02)
(19 3.98 5.05)
(18 4.00 5.09)
(17 4.02 5.14)
(16 4.05 5.19)
(15 4.08 5.25)
(14 4.11 5.32)
(13 4.15 5.40)
(12 4.20 5.50)
(11 4.26 5.62)
(10 4.33 5.77)
(9 4.41 5.96))
(3 ; K=3
; DF 0.05 0.01
(90 3.37 4.23)
(60 3.40 4.28)
(50 3.41 4.32)
(40 3.44 4.37)
(35 3.46 4.39)
(30 3.49 4.45)
(27 3.50 4.49)
(24 3.53 4.55)
(22 3.55 4.59)
(20 3.58 4.64)
(19 3.59 4.67)
(18 3.61 4.70)
(17 3.63 4.74)
(16 3.65 4.79)
(15 3.67 4.84)
(14 3.70 4.89)
(13 3.73 4.96)
(12 3.77 5.05)
(11 3.82 5.15)
(10 3.88 5.27)
(9 3.95 5.43))))
#| This example comes from: http://vassun.vassar.edu/~lowry/ch14pt1.html
(setq data '((27.0 26.2 28.8 33.5 28.8)
(22.8 23.1 27.7 27.6 24.0)
(21.9 23.4 20.1 27.8 19.3)
(23.5 19.6 23.7 20.8 23.9)))
|#
#| removed because mean-combinations and index-combinations are not defined
(defun Anova1+TukeyHSD (data)
"Tukey's HSD post hoc, using info from
http://vassun.vassar.edu/~lowry/ch14pt2.html
Calculates q values for all pairwise comparisons of the means in the
one-way ANOVA on the given data. The results are returned in a :HSD-QS
field, added to the ANOVA1 result, which looks like: ((q sig0.05
sig0.01 (datapos1 mean1) (datapos2 mean2))...) where the datapos are
the nth position in the data, and q is the Q value. The 0.05 and 0.01
sigs are '- or '+, based upon the K, DFwg and Q values. (Note that the
number of treatments is (length data), which is called K in the HSD
calculation, and = the between df+1.)"
(let* ((result (anova1 data))
(k (getf result :r))
(dfwg (getf result :SSEdf))
(denomenator (sqrt (/ (getf result :mse) (harmonic-mean (mapcar #'length data)))))
(qs (tukey-q k dfwg))
(q0.05 (first qs))
(q0.01 (second qs))
(hsd0.05 (* q0.05 denomenator))
(hsd0.01 (* q0.01 denomenator))
;; Cross subsets will work the same way in all cases, enabling
;; us to create the mean combinations, and their indexes:
;; (mean-combinations (bio::cross-subsets (getf result :MEANYI-)))
;; (index-combinations (bio::cross-subsets (loop for i below k collect i)))
)
(setf (getf result :tukey-params)
(list :denomenator denomenator
:q0.05 q0.05
:q0.01 q0.01
:hsd0.05 hsd0.05
:hsd0.01 hsd0.01
:dfwg dfwg))
(setf (getf result :tukey-hsds)
(loop for (m1 m2) in mean-combinations
as (i1 i2) in index-combinations
as mean-diff = (float (abs (- m1 m2)))
as Q = (/ mean-diff denomenator)
collect (list :q q
:sig0.05 (if (> mean-diff hsd0.05) '+ '-)
:sig0.01 (if (> mean-diff hsd0.01) '+ '-)
:i1 i1 :m1 (float m1)
:i2 i2 :m2 (float m2))))
result))
|#
(defun tukey-q (k dfwg)
"Finds the Q table for the appopriate K, and then walks BACKWARDS
through it (in a kind of ugly way!) to find the appropriate place in
the table for the DFwg, and then uses the level (which must be 0.01 or
0.05, indicating the first, or second col of the table) to determine
if the Q value reaches significance, and gives us a + or - final
result."
(loop for (dflimit . qs) in (or (cdr (assoc k *q-table*))
;; Use the highest if K isn't there.
(cdr (car *q-table*)))
until (<= dflimit dfwg)
finally (return qs)))
(defun harmonic-mean (seq)
"See: http://mathworld.wolfram.com/HarmonicMean.html"
(/ (float (length seq))
(loop for n in seq
sum (/ 1.0 n))))
;;; ----------------------------------------------------------------------------
(defun regress (x y)
"Simple linear regression."
(let* ((n (float (length x)))
(sumx (sum x))
(sumy (sum y))
(sumxy (sum (mapcar #'* x y)))
(sumx2 (sum (mapcar #'* x x)))
(m (/ (- (* n sumxy) (* sumx sumy))
(- (* n sumx2) (expt sumx 2))))
(b (+ (/ (* (- m) sumx) n)
(/ sumy n)))
(sumy2 (sum (mapcar #'* y y)))
(resids (mapcar (lambda (x y) (- y (+ (* x m) b))) x y))
(r (/ (- (* n sumxy) (* sumx sumy))
(sqrt (*
(- (* n sumx2) (expt (sum x) 2))
(- (* n sumy2) (expt (sum y) 2))
))))
(r2 (expt r 2)))
(list :m m :b b :resids resids :r r :r2 r2)))
(defun correlate (x y)
"Correlation of two sequences, as in Ferguson & Takane, 1989,
p. 125. Assumes NO MISSING VALUES!"
(if (not (= (length x) (length y)))
(break "Can only correlate equal-sized sets."))
(let* ((mx (mean x))
(my (mean y))
(n (length x))
(devx (mapcar (lambda (v) (- v mx)) x))
(devy (mapcar (lambda (v) (- v my)) y))
(sumdevxy (sum (mapcar #'* devx devy)))
(sumsqdevx (sum (sqr devx)))
(sumsqdevy (sum (sqr devy)))
(r (/ sumdevxy (sqrt (* sumsqdevx sumsqdevy)))))
(list :r r :r2 (sqr r) :n n :p (2-tailed-correlation-significance n (abs r)))))
;;; Critical Values of r
;;; One tailed is half of this:
(defvar *critical-values-of-r-two-tailed-column-interpretaion* '(0.2 0.1 0.05 0.02 0.01 0.001))
(defvar *critical-values-of-r* '(
; n ... 2-tailed testing / (1-tailed testing)
; 0.2 (0.1) 0.1 (0.05) 0.05 (0.025) 0.02 (0.01) 0.01 (0.005) 0.001 (0.0005)
(5 0.687 0.805 0.878 0.934 0.959 0.991)
(6 0.608 0.729 0.811 0.882 0.917 0.974)
(7 0.551 0.669 0.754 0.833 0.875 0.951)
(8 0.507 0.621 0.707 0.789 0.834 0.925)
(9 0.472 0.582 0.666 0.750 0.798 0.898)
(10 0.443 0.549 0.632 0.715 0.765 0.872)
(11 0.419 0.521 0.602 0.685 0.735 0.847)
(12 0.398 0.497 0.576 0.658 0.708 0.823)
(13 0.380 0.476 0.553 0.634 0.684 0.801)
(14 0.365 0.458 0.532 0.612 0.661 0.780)
(15 0.351 0.441 0.514 0.592 0.641 0.760)
(16 0.338 0.426 0.497 0.574 0.623 0.742)
(17 0.327 0.412 0.482 0.558 0.606 0.725)
(18 0.317 0.400 0.468 0.543 0.590 0.708)
(19 0.308 0.389 0.456 0.529 0.575 0.693)
(20 0.299 0.378 0.444 0.516 0.561 0.679)
(21 0.291 0.369 0.433 0.503 0.549 0.665)
(22 0.284 0.360 0.423 0.492 0.537 0.652)
(23 0.277 0.352 0.413 0.482 0.526 0.640)
(24 0.271 0.344 0.404 0.472 0.515 0.629)
(25 0.265 0.337 0.396 0.462 0.505 0.618)
(26 0.260 0.330 0.388 0.453 0.496 0.607)
(27 0.255 0.323 0.381 0.445 0.487 0.597)
(28 0.250 0.317 0.374 0.437 0.479 0.588)
(29 0.245 0.311 0.367 0.430 0.471 0.579)
(30 0.241 0.306 0.361 0.423 0.463 0.570)
(40 0.207 0.264 0.312 0.367 0.403 0.501)
(50 0.184 0.235 0.279 0.328 0.361 0.451)
(60 0.168 0.214 0.254 0.300 0.330 0.414)
(80 0.145 0.185 0.220 0.260 0.286 0.361)
(100 0.129 0.165 0.197 0.232 0.256 0.324)
(120 0.118 0.151 0.179 0.212 0.234 0.297)
(140 0.109 0.140 0.166 0.196 0.217 0.275)
(160 0.102 0.130 0.155 0.184 0.203 0.258)
(180 0.096 0.123 0.146 0.173 0.192 0.243)
(200 0.091 0.117 0.139 0.164 0.182 0.231)
(300 0.074 0.095 0.113 0.134 0.149 0.189)
(400 0.064 0.082 0.098 0.116 0.129 0.164)
(500 0.057 0.074 0.088 0.104 0.115 0.147)))
(defun 2-tailed-correlation-significance (n r)
"We use the first line for anything less than 5, and the last line
for anything over 500. Otherwise, find the nearest value (maybe we
should interpolate ... too much bother!)"
(let ((target-row (first *critical-values-of-r*)))
(when (> n 5)
(loop for row in *critical-values-of-r*
as (row-n . nil) = row
with last-row-n = 5
with last-row = target-row
do
(cond ((= row-n n)
(setq target-row row)
(return t))
((> row-n n)
(cond ((< (abs (- n row-n))
(abs (- n last-row-n)))
(setq target-row row))
(t (setq target-row last-row)))
(return t)))
(setq last-row row)
(setq last-row-n row-n)
finally (progn (setq target-row row)
(return t))))
(pop target-row) ; removes the N header
(cond ((< r (car target-row)) ">0.2")
(t (loop for crit in (cdr target-row)
as p in (cdr *critical-values-of-r-two-tailed-column-interpretaion*)
with last-p = (car *critical-values-of-r-two-tailed-column-interpretaion*)
when (< r crit)
do (return (format nil "<~a" last-p))
else do (setq last-p p)
finally (return (format nil "<~a" p)))))))
(defun even-power-of-two? (n)
(zerop (mod (/ (log n) (log 2)) 1)))
(defun normalize (v)
"Normalize a vector by dividing it through by subtracting its min
and then dividing through by its range (max-min). If the numbers are
all the same, this would screw up, so we check that first and just
return a long list of 0.5 if so!"
(let* ((mx (reduce #'max v))
(mn (reduce #'min v))
(range (float (- mx mn))))
(mapcar (lambda (i) (if (zerop range) 0.5
(/ (- i mn) range))) v)))
(defun dumplot (v &optional show-values)
"A dumb terminal way of plotting data."
(let* ((d1 (normalize v))
(d2 (mapcar (lambda (i) (* 50.0 i)) d1))
(min (reduce #'min v))
(max (reduce #'max v)))
(format t "~a~50t~a~%" min max)
(dolist (i d2)
(dotimes (k (round i))
(format t " "))
(if show-values
(format t "* = ~a~%" (p2 (car v)))
(format t "*~%"))
(pop v)))) ; follow along for showing values
(defun cross-mean (l &aux k r)
"Cross mean takes a list of lists, as ((1 2 3) (4 3 2 1) ...) and
produces a list with mean and standard error for each VERTICLE entry,
so, as: ((2.5 . 1) ...) where the first pair is computed from the nth
1 of all the sublists in the input set, etc. This is useful in some
cases of data cruching.
Note that missing data is assumed to be always at the END of lists.
If it isn't, you've got to do something previously to interpolate."
(let* ((nmax (reduce #'max (mapcar #'length l)))
(vs (make-array nmax)))
(dolist (i l)
(setq k 0)
(dolist (v i)
(push v (aref vs k))
(incf k)))
(dotimes (i nmax)
(push (cons (mean (aref vs i))
(standard-error (aref vs i)))
r))
(reverse r)))
(defmacro z/protect (expr testvar)
"Macro to protect from division by zero."
`(if (zerop ,testvar) "[/0!]" ,expr))
(defun histovalues (v* &key (nbins 10))
"Take a set of values and produce a histogram binned into n groups,
so that you can get a report of the distribution of values. There's a
large chance for off-by-one errores here!"
(let* ((min (min* v*))
(max (max* v*))
(inc (round (/ (abs (- min max)) nbins)))
(bins (loop with i = min
for n from 1 to nbins
collect (list i (incf i inc) 0))))
(loop for v in v*
do (loop for bin in bins
if (and (>= v (first bin))
(< v (second bin)))
do (incf (third bin))))
bins))
(defun x2test ()
"Simple Chi-Squares From Clarke & Cooke p. 431; should = ~7.0"
(chi-square-1 '(100 100 100 100 100 100 100 100 100 100)
'(106 88 97 101 92 103 96 112 114 91)))
(defun chi-square-1 (expected observed)
`(:x2 ,(loop for e in expected as o in observed
sum (/ (expt (- o e) 2) (float e)))
:df ,(1- (length expected))))
;;; I'm not sure what the setup is supposed to be for this one,
;;; since, like a moron I didn't give an example....
(defun chi-square-2 (table)
(let* ((row-mars (mapcar (lambda (row) (apply #'+ row)) table))
(col-mars (loop for col from 0 to (1- (length (car table)))
collect (apply #'+ (loop for row in table
collect (nth col row)))))
(total (float (apply #'+ row-mars)))
(expectable (loop for row in table
as rowmar in row-mars
collect (loop for col in row
as colmar in col-mars
collect (cons col (/ (* rowmar colmar) total))))))
(loop for row in expectable
sum (loop for entry in row
sum (/ (expt (- (car entry) (cdr entry)) 2) (cdr entry))))))
;;; This are the F score limit tables for anovas in the form: F(A,B)
;;; (From http://www.itl.nist.gov/div898/handbook/eda/section3/eda3673.htm)
;;; I *think* that A is the column df = number of columns - 1
;;; B is the row df = number of samples - number of columns
(defun f-score>p-limit? (df1 df2 f-score limits-table)
(let ((limit (nth df1 (assoc df2 limits-table))))
(cond (limit (> f-score limit))
(t (format t "Warning! F-score>p-limit? can't find an entry for F(~a,~a)!~%" df1 df2)))))
(defvar *F0.05* '(
; A: 1 2 3 4 5 6 7 8 9 10
;B:
( 1 161.448 199.500 215.707 224.583 230.162 233.986 236.768 238.882 240.543 241.882)
( 2 18.513 19.000 19.164 19.247 19.296 19.330 19.353 19.371 19.385 19.396)
( 3 10.128 9.552 9.277 9.117 9.013 8.941 8.887 8.845 8.812 8.786)
( 4 7.709 6.944 6.591 6.388 6.256 6.163 6.094 6.041 5.999 5.964)
( 5 6.608 5.786 5.409 5.192 5.050 4.950 4.876 4.818 4.772 4.735)
( 6 5.987 5.143 4.757 4.534 4.387 4.284 4.207 4.147 4.099 4.060)
( 7 5.591 4.737 4.347 4.120 3.972 3.866 3.787 3.726 3.677 3.637)
( 8 5.318 4.459 4.066 3.838 3.687 3.581 3.500 3.438 3.388 3.347)
( 9 5.117 4.256 3.863 3.633 3.482 3.374 3.293 3.230 3.179 3.137)
( 10 4.965 4.103 3.708 3.478 3.326 3.217 3.135 3.072 3.020 2.978)
( 11 4.844 3.982 3.587 3.357 3.204 3.095 3.012 2.948 2.896 2.854)
( 12 4.747 3.885 3.490 3.259 3.106 2.996 2.913 2.849 2.796 2.753)
( 13 4.667 3.806 3.411 3.179 3.025 2.915 2.832 2.767 2.714 2.671)
( 14 4.600 3.739 3.344 3.112 2.958 2.848 2.764 2.699 2.646 2.602)
( 15 4.543 3.682 3.287 3.056 2.901 2.790 2.707 2.641 2.588 2.544)
( 16 4.494 3.634 3.239 3.007 2.852 2.741 2.657 2.591 2.538 2.494)
( 17 4.451 3.592 3.197 2.965 2.810 2.699 2.614 2.548 2.494 2.450)
( 18 4.414 3.555 3.160 2.928 2.773 2.661 2.577 2.510 2.456 2.412)
( 19 4.381 3.522 3.127 2.895 2.740 2.628 2.544 2.477 2.423 2.378)
( 20 4.351 3.493 3.098 2.866 2.711 2.599 2.514 2.447 2.393 2.348)
( 21 4.325 3.467 3.072 2.840 2.685 2.573 2.488 2.420 2.366 2.321)
( 22 4.301 3.443 3.049 2.817 2.661 2.549 2.464 2.397 2.342 2.297)
( 23 4.279 3.422 3.028 2.796 2.640 2.528 2.442 2.375 2.320 2.275)
( 24 4.260 3.403 3.009 2.776 2.621 2.508 2.423 2.355 2.300 2.255)
( 25 4.242 3.385 2.991 2.759 2.603 2.490 2.405 2.337 2.282 2.236)
( 26 4.225 3.369 2.975 2.743 2.587 2.474 2.388 2.321 2.265 2.220)
( 27 4.210 3.354 2.960 2.728 2.572 2.459 2.373 2.305 2.250 2.204)
( 28 4.196 3.340 2.947 2.714 2.558 2.445 2.359 2.291 2.236 2.190)
( 29 4.183 3.328 2.934 2.701 2.545 2.432 2.346 2.278 2.223 2.177)
( 30 4.171 3.316 2.922 2.690 2.534 2.421 2.334 2.266 2.211 2.165)
( 31 4.160 3.305 2.911 2.679 2.523 2.409 2.323 2.255 2.199 2.153)
( 32 4.149 3.295 2.901 2.668 2.512 2.399 2.313 2.244 2.189 2.142)
( 33 4.139 3.285 2.892 2.659 2.503 2.389 2.303 2.235 2.179 2.133)
( 34 4.130 3.276 2.883 2.650 2.494 2.380 2.294 2.225 2.170 2.123)
( 35 4.121 3.267 2.874 2.641 2.485 2.372 2.285 2.217 2.161 2.114)
( 36 4.113 3.259 2.866 2.634 2.477 2.364 2.277 2.209 2.153 2.106)
( 37 4.105 3.252 2.859 2.626 2.470 2.356 2.270 2.201 2.145 2.098)
( 38 4.098 3.245 2.852 2.619 2.463 2.349 2.262 2.194 2.138 2.091)
( 39 4.091 3.238 2.845 2.612 2.456 2.342 2.255 2.187 2.131 2.084)
( 40 4.085 3.232 2.839 2.606 2.449 2.336 2.249 2.180 2.124 2.077)
( 41 4.079 3.226 2.833 2.600 2.443 2.330 2.243 2.174 2.118 2.071)
( 42 4.073 3.220 2.827 2.594 2.438 2.324 2.237 2.168 2.112 2.065)
( 43 4.067 3.214 2.822 2.589 2.432 2.318 2.232 2.163 2.106 2.059)
( 44 4.062 3.209 2.816 2.584 2.427 2.313 2.226 2.157 2.101 2.054)
( 45 4.057 3.204 2.812 2.579 2.422 2.308 2.221 2.152 2.096 2.049)
( 46 4.052 3.200 2.807 2.574 2.417 2.304 2.216 2.147 2.091 2.044)
( 47 4.047 3.195 2.802 2.570 2.413 2.299 2.212 2.143 2.086 2.039)
( 48 4.043 3.191 2.798 2.565 2.409 2.295 2.207 2.138 2.082 2.035)
( 49 4.038 3.187 2.794 2.561 2.404 2.290 2.203 2.134 2.077 2.030)
( 50 4.034 3.183 2.790 2.557 2.400 2.286 2.199 2.130 2.073 2.026)
( 51 4.030 3.179 2.786 2.553 2.397 2.283 2.195 2.126 2.069 2.022)
( 52 4.027 3.175 2.783 2.550 2.393 2.279 2.192 2.122 2.066 2.018)
( 53 4.023 3.172 2.779 2.546 2.389 2.275 2.188 2.119 2.062 2.015)
( 54 4.020 3.168 2.776 2.543 2.386 2.272 2.185 2.115 2.059 2.011)
( 55 4.016 3.165 2.773 2.540 2.383 2.269 2.181 2.112 2.055 2.008)
( 56 4.013 3.162 2.769 2.537 2.380 2.266 2.178 2.109 2.052 2.005)
( 57 4.010 3.159 2.766 2.534 2.377 2.263 2.175 2.106 2.049 2.001)
( 58 4.007 3.156 2.764 2.531 2.374 2.260 2.172 2.103 2.046 1.998)
( 59 4.004 3.153 2.761 2.528 2.371 2.257 2.169 2.100 2.043 1.995)
( 60 4.001 3.150 2.758 2.525 2.368 2.254 2.167 2.097 2.040 1.993)
( 61 3.998 3.148 2.755 2.523 2.366 2.251 2.164 2.094 2.037 1.990)
( 62 3.996 3.145 2.753 2.520 2.363 2.249 2.161 2.092 2.035 1.987)
( 63 3.993 3.143 2.751 2.518 2.361 2.246 2.159 2.089 2.032 1.985)
( 64 3.991 3.140 2.748 2.515 2.358 2.244 2.156 2.087 2.030 1.982)
( 65 3.989 3.138 2.746 2.513 2.356 2.242 2.154 2.084 2.027 1.980)
( 66 3.986 3.136 2.744 2.511 2.354 2.239 2.152 2.082 2.025 1.977)
( 67 3.984 3.134 2.742 2.509 2.352 2.237 2.150 2.080 2.023 1.975)
( 68 3.982 3.132 2.740 2.507 2.350 2.235 2.148 2.078 2.021 1.973)
( 69 3.980 3.130 2.737 2.505 2.348 2.233 2.145 2.076 2.019 1.971)
( 70 3.978 3.128 2.736 2.503 2.346 2.231 2.143 2.074 2.017 1.969)
( 71 3.976 3.126 2.734 2.501 2.344 2.229 2.142 2.072 2.015 1.967)
( 72 3.974 3.124 2.732 2.499 2.342 2.227 2.140 2.070 2.013 1.965)
( 73 3.972 3.122 2.730 2.497 2.340 2.226 2.138 2.068 2.011 1.963)
( 74 3.970 3.120 2.728 2.495 2.338 2.224 2.136 2.066 2.009 1.961)
( 75 3.968 3.119 2.727 2.494 2.337 2.222 2.134 2.064 2.007 1.959)
( 76 3.967 3.117 2.725 2.492 2.335 2.220 2.133 2.063 2.006 1.958)
( 77 3.965 3.115 2.723 2.490 2.333 2.219 2.131 2.061 2.004 1.956)
( 78 3.963 3.114 2.722 2.489 2.332 2.217 2.129 2.059 2.002 1.954)
( 79 3.962 3.112 2.720 2.487 2.330 2.216 2.128 2.058 2.001 1.953)
( 80 3.960 3.111 2.719 2.486 2.329 2.214 2.126 2.056 1.999 1.951)
( 81 3.959 3.109 2.717 2.484 2.327 2.213 2.125 2.055 1.998 1.950)
( 82 3.957 3.108 2.716 2.483 2.326 2.211 2.123 2.053 1.996 1.948)
( 83 3.956 3.107 2.715 2.482 2.324 2.210 2.122 2.052 1.995 1.947)
( 84 3.955 3.105 2.713 2.480 2.323 2.209 2.121 2.051 1.993 1.945)
( 85 3.953 3.104 2.712 2.479 2.322 2.207 2.119 2.049 1.992 1.944)
( 86 3.952 3.103 2.711 2.478 2.321 2.206 2.118 2.048 1.991 1.943)
( 87 3.951 3.101 2.709 2.476 2.319 2.205 2.117 2.047 1.989 1.941)
( 88 3.949 3.100 2.708 2.475 2.318 2.203 2.115 2.045 1.988 1.940)
( 89 3.948 3.099 2.707 2.474 2.317 2.202 2.114 2.044 1.987 1.939)
( 90 3.947 3.098 2.706 2.473 2.316 2.201 2.113 2.043 1.986 1.938)
( 91 3.946 3.097 2.705 2.472 2.315 2.200 2.112 2.042 1.984 1.936)
( 92 3.945 3.095 2.704 2.471 2.313 2.199 2.111 2.041 1.983 1.935)
( 93 3.943 3.094 2.703 2.470 2.312 2.198 2.110 2.040 1.982 1.934)
( 94 3.942 3.093 2.701 2.469 2.311 2.197 2.109 2.038 1.981 1.933)
( 95 3.941 3.092 2.700 2.467 2.310 2.196 2.108 2.037 1.980 1.932)
( 96 3.940 3.091 2.699 2.466 2.309 2.195 2.106 2.036 1.979 1.931)
( 97 3.939 3.090 2.698 2.465 2.308 2.194 2.105 2.035 1.978 1.930)
( 98 3.938 3.089 2.697 2.465 2.307 2.193 2.104 2.034 1.977 1.929)
( 99 3.937 3.088 2.696 2.464 2.306 2.192 2.103 2.033 1.976 1.928)
(100 3.936 3.087 2.696 2.463 2.305 2.191 2.103 2.032 1.975 1.927)
))
(defvar *F0.10* '(
; A: 1 2 3 4 5 6 7 8 9 10
;B:
( 1 39.863 49.500 53.593 55.833 57.240 58.204 58.906 59.439 59.858 60.195)
( 2 8.526 9.000 9.162 9.243 9.293 9.326 9.349 9.367 9.381 9.392)
( 3 5.538 5.462 5.391 5.343 5.309 5.285 5.266 5.252 5.240 5.230)
( 4 4.545 4.325 4.191 4.107 4.051 4.010 3.979 3.955 3.936 3.920)
( 5 4.060 3.780 3.619 3.520 3.453 3.405 3.368 3.339 3.316 3.297)
( 6 3.776 3.463 3.289 3.181 3.108 3.055 3.014 2.983 2.958 2.937)
( 7 3.589 3.257 3.074 2.961 2.883 2.827 2.785 2.752 2.725 2.703)
( 8 3.458 3.113 2.924 2.806 2.726 2.668 2.624 2.589 2.561 2.538)
( 9 3.360 3.006 2.813 2.693 2.611 2.551 2.505 2.469 2.440 2.416)
( 10 3.285 2.924 2.728 2.605 2.522 2.461 2.414 2.377 2.347 2.323)
( 11 3.225 2.860 2.660 2.536 2.451 2.389 2.342 2.304 2.274 2.248)
( 12 3.177 2.807 2.606 2.480 2.394 2.331 2.283 2.245 2.214 2.188)
( 13 3.136 2.763 2.560 2.434 2.347 2.283 2.234 2.195 2.164 2.138)
( 14 3.102 2.726 2.522 2.395 2.307 2.243 2.193 2.154 2.122 2.095)
( 15 3.073 2.695 2.490 2.361 2.273 2.208 2.158 2.119 2.086 2.059)
( 16 3.048 2.668 2.462 2.333 2.244 2.178 2.128 2.088 2.055 2.028)
( 17 3.026 2.645 2.437 2.308 2.218 2.152 2.102 2.061 2.028 2.001)
( 18 3.007 2.624 2.416 2.286 2.196 2.130 2.079 2.038 2.005 1.977)
( 19 2.990 2.606 2.397 2.266 2.176 2.109 2.058 2.017 1.984 1.956)
( 20 2.975 2.589 2.380 2.249 2.158 2.091 2.040 1.999 1.965 1.937)
( 21 2.961 2.575 2.365 2.233 2.142 2.075 2.023 1.982 1.948 1.920)
( 22 2.949 2.561 2.351 2.219 2.128 2.060 2.008 1.967 1.933 1.904)
( 23 2.937 2.549 2.339 2.207 2.115 2.047 1.995 1.953 1.919 1.890)
( 24 2.927 2.538 2.327 2.195 2.103 2.035 1.983 1.941 1.906 1.877)
( 25 2.918 2.528 2.317 2.184 2.092 2.024 1.971 1.929 1.895 1.866)
( 26 2.909 2.519 2.307 2.174 2.082 2.014 1.961 1.919 1.884 1.855)
( 27 2.901 2.511 2.299 2.165 2.073 2.005 1.952 1.909 1.874 1.845)
( 28 2.894 2.503 2.291 2.157 2.064 1.996 1.943 1.900 1.865 1.836)
( 29 2.887 2.495 2.283 2.149 2.057 1.988 1.935 1.892 1.857 1.827)
( 30 2.881 2.489 2.276 2.142 2.049 1.980 1.927 1.884 1.849 1.819)
( 31 2.875 2.482 2.270 2.136 2.042 1.973 1.920 1.877 1.842 1.812)
( 32 2.869 2.477 2.263 2.129 2.036 1.967 1.913 1.870 1.835 1.805)
( 33 2.864 2.471 2.258 2.123 2.030 1.961 1.907 1.864 1.828 1.799)
( 34 2.859 2.466 2.252 2.118 2.024 1.955 1.901 1.858 1.822 1.793)
( 35 2.855 2.461 2.247 2.113 2.019 1.950 1.896 1.852 1.817 1.787)
( 36 2.850 2.456 2.243 2.108 2.014 1.945 1.891 1.847 1.811 1.781)
( 37 2.846 2.452 2.238 2.103 2.009 1.940 1.886 1.842 1.806 1.776)
( 38 2.842 2.448 2.234 2.099 2.005 1.935 1.881 1.838 1.802 1.772)
( 39 2.839 2.444 2.230 2.095 2.001 1.931 1.877 1.833 1.797 1.767)
( 40 2.835 2.440 2.226 2.091 1.997 1.927 1.873 1.829 1.793 1.763)
( 41 2.832 2.437 2.222 2.087 1.993 1.923 1.869 1.825 1.789 1.759)
( 42 2.829 2.434 2.219 2.084 1.989 1.919 1.865 1.821 1.785 1.755)
( 43 2.826 2.430 2.216 2.080 1.986 1.916 1.861 1.817 1.781 1.751)
( 44 2.823 2.427 2.213 2.077 1.983 1.913 1.858 1.814 1.778 1.747)
( 45 2.820 2.425 2.210 2.074 1.980 1.909 1.855 1.811 1.774 1.744)
( 46 2.818 2.422 2.207 2.071 1.977 1.906 1.852 1.808 1.771 1.741)
( 47 2.815 2.419 2.204 2.068 1.974 1.903 1.849 1.805 1.768 1.738)
( 48 2.813 2.417 2.202 2.066 1.971 1.901 1.846 1.802 1.765 1.735)
( 49 2.811 2.414 2.199 2.063 1.968 1.898 1.843 1.799 1.763 1.732)
( 50 2.809 2.412 2.197 2.061 1.966 1.895 1.840 1.796 1.760 1.729)
( 51 2.807 2.410 2.194 2.058 1.964 1.893 1.838 1.794 1.757 1.727)
( 52 2.805 2.408 2.192 2.056 1.961 1.891 1.836 1.791 1.755 1.724)
( 53 2.803 2.406 2.190 2.054 1.959 1.888 1.833 1.789 1.752 1.722)
( 54 2.801 2.404 2.188 2.052 1.957 1.886 1.831 1.787 1.750 1.719)
( 55 2.799 2.402 2.186 2.050 1.955 1.884 1.829 1.785 1.748 1.717)
( 56 2.797 2.400 2.184 2.048 1.953 1.882 1.827 1.782 1.746 1.715)
( 57 2.796 2.398 2.182 2.046 1.951 1.880 1.825 1.780 1.744 1.713)
( 58 2.794 2.396 2.181 2.044 1.949 1.878 1.823 1.779 1.742 1.711)
( 59 2.793 2.395 2.179 2.043 1.947 1.876 1.821 1.777 1.740 1.709)
( 60 2.791 2.393 2.177 2.041 1.946 1.875 1.819 1.775 1.738 1.707)
( 61 2.790 2.392 2.176 2.039 1.944 1.873 1.818 1.773 1.736 1.705)
( 62 2.788 2.390 2.174 2.038 1.942 1.871 1.816 1.771 1.735 1.703)
( 63 2.787 2.389 2.173 2.036 1.941 1.870 1.814 1.770 1.733 1.702)
( 64 2.786 2.387 2.171 2.035 1.939 1.868 1.813 1.768 1.731 1.700)
( 65 2.784 2.386 2.170 2.033 1.938 1.867 1.811 1.767 1.730 1.699)
( 66 2.783 2.385 2.169 2.032 1.937 1.865 1.810 1.765 1.728 1.697)
( 67 2.782 2.384 2.167 2.031 1.935 1.864 1.808 1.764 1.727 1.696)
( 68 2.781 2.382 2.166 2.029 1.934 1.863 1.807 1.762 1.725 1.694)
( 69 2.780 2.381 2.165 2.028 1.933 1.861 1.806 1.761 1.724 1.693)
( 70 2.779 2.380 2.164 2.027 1.931 1.860 1.804 1.760 1.723 1.691)
( 71 2.778 2.379 2.163 2.026 1.930 1.859 1.803 1.758 1.721 1.690)
( 72 2.777 2.378 2.161 2.025 1.929 1.858 1.802 1.757 1.720 1.689)
( 73 2.776 2.377 2.160 2.024 1.928 1.856 1.801 1.756 1.719 1.687)
( 74 2.775 2.376 2.159 2.022 1.927 1.855 1.800 1.755 1.718 1.686)
( 75 2.774 2.375 2.158 2.021 1.926 1.854 1.798 1.754 1.716 1.685)
( 76 2.773 2.374 2.157 2.020 1.925 1.853 1.797 1.752 1.715 1.684)
( 77 2.772 2.373 2.156 2.019 1.924 1.852 1.796 1.751 1.714 1.683)
( 78 2.771 2.372 2.155 2.018 1.923 1.851 1.795 1.750 1.713 1.682)
( 79 2.770 2.371 2.154 2.017 1.922 1.850 1.794 1.749 1.712 1.681)
( 80 2.769 2.370 2.154 2.016 1.921 1.849 1.793 1.748 1.711 1.680)
( 81 2.769 2.369 2.153 2.016 1.920 1.848 1.792 1.747 1.710 1.679)
( 82 2.768 2.368 2.152 2.015 1.919 1.847 1.791 1.746 1.709 1.678)
( 83 2.767 2.368 2.151 2.014 1.918 1.846 1.790 1.745 1.708 1.677)
( 84 2.766 2.367 2.150 2.013 1.917 1.845 1.790 1.744 1.707 1.676)
( 85 2.765 2.366 2.149 2.012 1.916 1.845 1.789 1.744 1.706 1.675)
( 86 2.765 2.365 2.149 2.011 1.915 1.844 1.788 1.743 1.705 1.674)
( 87 2.764 2.365 2.148 2.011 1.915 1.843 1.787 1.742 1.705 1.673)
( 88 2.763 2.364 2.147 2.010 1.914 1.842 1.786 1.741 1.704 1.672)
( 89 2.763 2.363 2.146 2.009 1.913 1.841 1.785 1.740 1.703 1.671)
( 90 2.762 2.363 2.146 2.008 1.912 1.841 1.785 1.739 1.702 1.670)
( 91 2.761 2.362 2.145 2.008 1.912 1.840 1.784 1.739 1.701 1.670)
( 92 2.761 2.361 2.144 2.007 1.911 1.839 1.783 1.738 1.701 1.669)
( 93 2.760 2.361 2.144 2.006 1.910 1.838 1.782 1.737 1.700 1.668)
( 94 2.760 2.360 2.143 2.006 1.910 1.838 1.782 1.736 1.699 1.667)
( 95 2.759 2.359 2.142 2.005 1.909 1.837 1.781 1.736 1.698 1.667)
( 96 2.759 2.359 2.142 2.004 1.908 1.836 1.780 1.735 1.698 1.666)
( 97 2.758 2.358 2.141 2.004 1.908 1.836 1.780 1.734 1.697 1.665)
( 98 2.757 2.358 2.141 2.003 1.907 1.835 1.779 1.734 1.696 1.665)
( 99 2.757 2.357 2.140 2.003 1.906 1.835 1.778 1.733 1.696 1.664)
(100 2.756 2.356 2.139 2.002 1.906 1.834 1.778 1.732 1.695 1.663)
))
(defun wilcoxon-1 (initial-values target)
"Nonparametric one-sample (signed) rank test (Wilcoxon).
From http://www.graphpad.com/instatman/HowtheWilcoxonranksumtestworks.htm"
(let ((n 0)
r/v/d*
(sum+ranks 0)
(sum-ranks 0))
;; 1. Calculate how far each value is from the hypothetical value.
;; 2. Ignore values that exactly equal the hypothetical value. Call the
;; number of remaining values N.
(dolist (v initial-values)
(when (not (= target v))
(push (list 'rank v (abs (- target v))) r/v/d*)
(incf n)))
;; 3. Rank these distances, paying no attention to whether the values are
;; higher or lower than the hypothetical value.
(setq r/v/d* (sort r/v/d* (lambda (a b) (< (third a) (third b)))))
;; Ranking doesn't deal with ties!!!
(loop for entry in r/v/d*
as rank from 1 by 1
do (setf (car entry) rank))
;; 4. For each value that is lower than the hypothetical value, multiply
;; the rank by negative 1.
(loop for entry in r/v/d*
as (rank value nil) = entry
when (< value target)
do (setf (car entry) (- rank)))
;; 5. Sum the positive ranks. InStat reports this value.
;; 6. Sum the negative ranks. InStat also reports this value.
;; 7. Add the two sums together. This is the sum of signed ranks, which
;; InStat reports as W.
(print r/v/d*)
;; If the data really were sampled from a population with the
;; hypothetical mean, you'd expect W to be near zero. If W (the sum of
;; signed ranks) is far from zero, the P value will be small. The P value
;; answers this question: Assume that you randomly sample N values from a
;; population with the hypothetical median. What is the chance that W
;; will be as far from zero (or further) as you observed?
(loop for (rank nil nil) in r/v/d*
do (cond ((> rank 0) (incf sum+ranks rank))
((< rank 0) (incf sum-ranks rank)))
finally (return (values sum+ranks sum-ranks (+ sum+ranks sum-ranks))))))
#+not-completed
(defun rank-values (v*)
"Rank a list properly, including dealing with ties. This takes a
value list (30 20 30 40 50 60 ...) and returns the list sorted and
ranked in pairs, as (for the above): ((20 . 1) (30 . 2.5) (30 . 2.5) (40 . 4) (50 . 5)...)
Notice that the two 30's split the rank position for 2 and 3 equally; Any number
of ties will split the positional difference, so, three ties will end up on an integer.
This is done in two passes. First we sort and assign sequential integers. Then
we re-assign ties."
(let* ((v/r* (loop for v in v* collect (cons v 'rank)))
(v/r* (sort v/r* (lambda (a b) (< (car a) (car b)))))
(ignore (loop for v/r in v/r* as rank from 1 by 1
do (setf (cdr v/r) rank))))
(loop for v/r+ on v/r*
as major-rank from 1 by 1
with minor-rank = 1
as count = (loop with target = (caar v/r+)
as (next . minor-rank) in (cdr v/r+)
as k from 1 by 1
until (not (= next target))
finally (return k))
do
(print (list (car v/r+) minor-rank count))
(when (not (= 1 count))
(let ((new-rank (+ minor-rank (/ count 2.0))))
(loop with target = (caar v/r+)
as entry in (cdr v/r+)
as (next . minor-rank) = entry
until (not (= next target))
do (setf (cdr entry) new-rank))))
(setf minor-rank (+ rank count)))
v/r*))
| 123,811 | Common Lisp | .lisp | 2,461 | 40.647298 | 117 | 0.524959 | mrc/lhstats | 14 | 4 | 1 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | f03bd82df5130d95b51b0ad97a7da59bf01c678f811b19a7e0a054acf629ac50 | 7,816 | [
-1
] |
7,817 | package.lisp | mrc_lhstats/package.lisp | ;;;; package.lisp
(defpackage :statistics
(:documentation "Statistical functions")
(:nicknames :stats)
(:use #:cl)
(:export #:mean #:median #:mode #:geometric-mean #:range #:percentile
#:variance #:standard-deviation #:sd #:coefficient-of-variation
#:standard-error-of-the-mean #:permutations #:choose
#:binomial-probability #:binomial-cumulative-probability
#:binomial-ge-probability #:poisson-probability
#:poisson-cumulative-probability #:poisson-ge-probability
#:poisson-cdf #:normal-pdf #:convert-to-standard-normal #:phi #:z
#:t-distribution #:chi-square #:chi-square-cdf
#:binomial-probability-ci #:poisson-mu-ci #:normal-mean-ci
#:normal-mean-ci-on-sequence #:normal-variance-ci
#:normal-variance-ci-on-sequence #:normal-sd-ci
#:normal-sd-ci-on-sequence #:z-test #:z-test-on-sequence
#:t-test-one-sample #:t-test-one-sample-on-sequence
#:t-test-paired #:t-test-paired-on-sequences #:t-test-two-sample
#:t-test-two-sample-on-sequences #:chi-square-test-one-sample
#:f-test #:binomial-test-one-sample #:binomial-test-two-sample
#:fisher-exact-test #:mcnemars-test #:poisson-test-one-sample
#:sign-test #:sign-test-on-sequences #:wilcoxon-signed-rank-test
#:wilcoxon-signed-rank-test-on-sequences
#:chi-square-test-rxc #:chi-square-test-for-trend
#:t-test-one-sample-sse #:t-test-two-sample-sse
#:t-test-paired-sse #:binomial-test-one-sample-sse
#:binomial-test-two-sample-sse #:binomial-test-paired-sse
#:correlation-sse #:linear-regression #:correlation-coefficient
#:correlation-test-two-sample
#:correlation-test-two-sample-on-sequences #:spearman-rank-correlation
#:t-significance #:f-significance #:random-sample #:random-pick #:test-variables
#:bin-and-count #:fisher-z-transform #:mean-sd-n #:square
#:round-float #:false-discovery-correction
#:random-normal))
| 2,103 | Common Lisp | .lisp | 35 | 49.685714 | 91 | 0.64666 | mrc/lhstats | 14 | 4 | 1 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | af1cd7b79f7019fa7c2fa03ec19335d0ca33ca36edc160ccab0927b617f732f3 | 7,817 | [
-1
] |
7,818 | lhstats.asd | mrc_lhstats/lhstats.asd | ;;;; lhstats.asd
(asdf:defsystem #:lhstats
:description "Statistical functions by Larry Hunter and Jeff Shrager."
:author "Larry Hunter, Jeff Shrager"
:maintainer "Matt Curtis <[email protected]>"
:licence "GNU General Public License version 2 (GPLv2)"
:name "lhstats"
:version "1.01.1"
:serial t
:components ((:file "package")
(:file "lhstats")))
| 387 | Common Lisp | .asd | 11 | 31.181818 | 72 | 0.692513 | mrc/lhstats | 14 | 4 | 1 | GPL-2.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 1b43a844b6c2a57311d35fdf0ea40b715d4ef51b4ee2107fa306c0a79820eb28 | 7,818 | [
-1
] |
7,836 | cljwt.lisp | gschjetne_cljwt/src/cljwt.lisp | ;; Copyright © 2014 Grim Schjetne <[email protected]>
;; This file is part of CLJWT.
;; CLJWT is free software: you can redistribute it and/or modify
;; it under the terms of the GNU Lesser General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.
;; CLJWT is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; Lesser General Public License for more details.
;; You should have received a copy of the GNU Lesser General Public
;; License along with CLJWT. If not, see
;; <http://www.gnu.org/licenses/>.
(in-package #:cl-user)
(defpackage #:cljwt
(:use #:cl
#:cl-base64)
(:import-from #:alexandria
#:plist-hash-table)
(:import-from #:flexi-streams
#:string-to-octets
#:octets-to-string)
(:import-from #:ironclad
#:make-hmac
#:update-hmac
#:hmac-digest)
(:import-from #:split-sequence
#:split-sequence)
(:export #:issue
#:decode
#:to-unix-time
#:from-unix-time
#:unsecured-token
#:invalid-hmac
#:unsupported-algorithm
#:invalid-time
#:expired
#:not-yet-valid))
(in-package #:cljwt)
(defmacro bind-hash-tables (bindings &body body)
`(let ,(loop for binding in bindings collect
(list (car binding)
`(etypecase ,(cadr binding)
(hash-table ,(cadr binding))
(list (plist-hash-table ,(cadr binding)
:test #'equal)))))
,@body))
(defmacro add-claims (hash &rest claims)
`(progn ,@(loop for (key value) on claims by #'cddr collect
`(when ,value
(setf (gethash ,key ,hash) ,value)))))
(defun to-unix-time (time)
"Convert universal time to New Jersey time"
(when time (- time (encode-universal-time 0 0 0 1 1 1970 0))))
(defun from-unix-time (time)
"Convert New Jersey time to universal time"
(when time (+ time (encode-universal-time 0 0 0 1 1 1970 0))))
(defun base64-encode (input)
"Takes a string or octets, returns an unpadded URI-encoded Base64 string."
(etypecase input
(string (base64-encode (string-to-octets input :external-format :utf-8)))
((simple-array (unsigned-byte 8))
(with-output-to-string (out)
(with-input-from-string (in (usb8-array-to-base64-string input :uri t))
(loop for character = (read-char in nil)
while character do
;; CL-BASE64 always uses padding, which must be removed.
(unless (eq character #\.)
(write-char character out))))))))
(defun base64-decode (base-64-string)
"Takes a base64-uri string and return an array of octets"
(base64-string-to-usb8-array
;; Re-pad the string, or CL-BASE64 will get confused
(concatenate 'string
base-64-string
(make-array (rem (length base-64-string) 4)
:element-type 'character
:initial-element #\.))
:uri t))
(defun issue (claims &key algorithm secret issuer subject audience
expiration not-before issued-at id more-header)
"Encodes and returns a JSON Web Token. Times are in universal-time,
number of seconds from 1900-01-01 00:00:00"
(bind-hash-tables ((claimset claims)
(header more-header))
;; Add registered claims to the claims hash table
(add-claims claimset
"iss" issuer
"sub" subject
"aud" audience
"exp" (to-unix-time expiration)
"nbf" (to-unix-time not-before)
"iat" (to-unix-time issued-at)
"jti" id)
;; Add type and algorithm to the header hash table
(add-claims header
"typ" "JWT"
"alg" (ecase algorithm
(:none "none")
(:hs256 "HS256")))
;; Prepare JSON
(let ((header-string (base64-encode
(with-output-to-string (s)
(yason:encode header s))))
(claims-string (base64-encode
(with-output-to-string (s)
(yason:encode claimset s)))))
;; Assemble and, if applicable, sign the JWT
(format nil "~A.~A.~@[~A~]"
header-string
claims-string
(when (eq algorithm :hs256)
(HS256-digest header-string
claims-string
secret))))))
(defun HS256-digest (header-string claims-string secret)
"Takes header and claims in Base64, secret as a string or octets,
returns the digest, in Base64"
(base64-encode
(hmac-digest
(update-hmac
(make-hmac (etypecase secret
((simple-array (unsigned-byte 8))
secret)
(string
(string-to-octets secret
:external-format :utf-8)))
'ironclad:SHA256)
(concatenate '(vector (unsigned-byte 8))
(string-to-octets
header-string)
#(46) ; ASCII period (.)
(string-to-octets
claims-string))))))
(defun compare-HS256-digest (header-string claims-string
secret reported-digest)
"Takes header and claims in Base64, secret as a string or octets, and a digest in Base64 to compare with. Signals an error if there is a mismatch."
(let ((computed-digest
(HS256-digest header-string
claims-string
secret)))
(unless (equalp computed-digest
reported-digest)
(cerror "Continue anyway" 'invalid-hmac
:reported-digest reported-digest
:computed-digest computed-digest))))
(defun decode (jwt-string &key secret fail-if-unsecured)
"Decodes and verifies a JSON Web Token. Returns two hash tables,
token claims and token header"
(destructuring-bind (header-string claims-string digest-string)
(split-sequence #\. jwt-string)
(let* ((header-hash (yason:parse
(octets-to-string
(base64-decode
header-string)
:external-format :utf-8)))
(claims-hash (yason:parse
(octets-to-string
(base64-decode
claims-string)
:external-format :utf-8)))
(algorithm (gethash "alg" header-hash)))
;; Verify HMAC
(cond ((equal algorithm "HS256")
(compare-HS256-digest header-string
claims-string
secret
digest-string))
((and (or (null algorithm) (equal algorithm "none")) fail-if-unsecured)
(cerror "Continue anyway" 'unsecured-token))
(t (cerror "Continue anyway" 'unsupported-algorithm
:algorithm algorithm)))
;; Verify timestamps
(let ((expires (from-unix-time (gethash "exp" claims-hash)))
(not-before (from-unix-time (gethash "nbf" claims-hash)))
(current-time (get-universal-time)))
(when (and expires (> current-time expires))
(cerror "Continue anyway" 'expired :delta (- current-time expires)))
(when (and not-before (< current-time not-before))
(cerror "Continue anyway" 'not-yet-valid :delta (- current-time not-before))))
;; Return hashes
(values claims-hash header-hash))))
;;; Conditions
(define-condition unsecured-token (error) ())
(define-condition invalid-hmac (error) ())
(define-condition unsupported-algorithm (error)
((algorithm :initarg :algorithm :reader algorithm))
(:report (lambda (condition stream)
(format stream "Algorithm \"~A\" not supported"
(algorithm condition)))))
(define-condition invalid-time (error)
((delta :initarg :delta :reader time-delta))
(:report (lambda (condition stream)
(format stream "Token ~A. ~D seconds off."
(typecase condition
(expired "has expired")
(not-yet-valid "is not yet valid"))
(time-delta condition)))))
(define-condition expired (invalid-time) ())
(define-condition not-yet-valid (invalid-time) ())
| 8,815 | Common Lisp | .lisp | 200 | 32.11 | 149 | 0.567621 | gschjetne/cljwt | 14 | 8 | 6 | LGPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | 531b9a28ee4f740ba5b7c448481ae66962d9156a75112e20220610cd723ab699 | 7,836 | [
-1
] |
7,837 | cljwt.asd | gschjetne_cljwt/cljwt.asd | ;; Copyright © 2014 Grim Schjetne <[email protected]>
;; This file is part of CLJWT.
;; CLJWT is free software: you can redistribute it and/or modify
;; it under the terms of the GNU Lesser General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.
;; CLJWT is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; Lesser General Public License for more details.
;; You should have received a copy of the GNU Lesser General Public
;; License along with CLJWT. If not, see
;; <http://www.gnu.org/licenses/>.
(in-package :cl-user)
(defpackage :cljwt-system (:use :cl :asdf))
(in-package :cljwt-system)
(defsystem cljwt
:name "CLJWT"
:author "Grim Schjetne <[email protected]"
:description "JSON Web Token library"
:license "LGPLv3+"
:depends-on (:ironclad
:yason
:cl-base64
:flexi-streams
:split-sequence)
:components
((:module "src"
:serial t
:components
((:file "cljwt")))))
| 1,211 | Common Lisp | .asd | 31 | 34.322581 | 69 | 0.689949 | gschjetne/cljwt | 14 | 8 | 6 | LGPL-3.0 | 9/19/2024, 11:26:41 AM (Europe/Amsterdam) | f38b633ae5efdfdeeafdce00b6afbadddb64fb41cef949962dde874114b62d78 | 7,837 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.