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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
34,010 | replace-slices.lsp | rwoldford_Quail/source/quail-kernel/array/replace-slices.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; replace-slices.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1994 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; R.W. Oldford 1994.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(replace-slices)))
;--------------------------------------------------------------------------------
(defun replace-slices (ref-object
&key
(slices :elements)
(function #'identity)
(copy? T))
"Replaces every slice of ref-object by the result of calling function ~
on that slice. This means that function ~
must return an object of identical dimensions to the original slice. ~
By default, replace-slices is not destructive to the original ref-object.~
If copy? is NIL then replace-slices will operate directly on the ref-object. ~
Returns the ref-object, or copy, with slices replaced. ~
(:see-also substitute-slices substitute-slices-if doslices collect-slices)~
(:required ~
(:arg ref-object The source whose slices will be replaced.) ~
) ~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
(:arg function #'identity A function of one argument ~
to be called on each slice. The slice is replaced by the result, so function must ~
return an object having the same dimensions as the original slice.) ~
(:arg copy? T If NIL, then the slices of ref-object are replaced directly. ~
Otherwise a copy is made first.) ~
)~
"
(when (numberp slices) (setf slices (list slices)))
(if copy? (setf ref-object (sel ref-object)))
(loop for i from 0 to (- (number-of-slices ref-object slices) 1)
do
(setf (column-major-ref-slice ref-object slices i)
(funcall function (column-major-ref-slice ref-object slices i))))
ref-object)
| 2,982 | Common Lisp | .l | 61 | 42.508197 | 88 | 0.576382 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | a54d545090451aeb3c3d2c17cabdfa550d9cbd5b2fb2b0bc0cb85adc319a5ffe | 34,010 | [
-1
] |
34,011 | count-slices.lsp | rwoldford_Quail/source/quail-kernel/array/count-slices.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; count-slices.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1994 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; R.W. Oldford 1994.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(count-slices count-slices-if)))
;--------------------------------------------------------------------------------
(defun count-slices (item ref-object
&key
(slices :elements)
(test #'ref-eq))
"Counts all slices in ref-object which match item when the function test ~
is applied to item and the slice of ref-object.~
It returns the number of slices found.~
(:see-also count-slices-if count doslices collect-slices)~
(:required ~
(:arg item The item to be compared to each slice in ref-object.)~
(:arg ref-object The source of the slices which will be compared to item.) ~
) ~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
(:arg test #'ref-eq The function to be called on item and slice. If it returns ~
non-NIL then that slice is counted.)~
)~
"
(when (numberp slices) (setf slices (list slices)))
(let ((count 0))
(doslices (slice ref-object slices)
(if (funcall test item slice)
(incf count)))
count))
(defun count-slices-if (pred ref-object
&key
(slices :elements))
"Counts every slice in ref-object which returns non-NIL ~
when the function pred is applied to it.~
It returns the number of slices found.~
(:see-also count-slices count-if doslices collect-slices)~
(:required ~
(:arg pred The predicate function to be applied to each slice.) ~
(:arg ref-object The source of the slices which will be compared to item.) ~
) ~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
)~
"
(when (numberp slices) (setf slices (list slices)))
(let ((count 0))
(doslices (slice ref-object slices)
(if (funcall pred slice)
(incf count)))
count)
)
| 3,936 | Common Lisp | .l | 88 | 38.363636 | 97 | 0.589744 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 0166ae1763436324e28161218f1957088d4da10d653b1bf46c563660b106b31b | 34,011 | [
-1
] |
34,012 | array.lsp | rwoldford_Quail/source/quail-kernel/array/array.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; array.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1993 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1993.
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
;#+:sbcl-linux(shadow '(array dimensions)) ;; OUT 15 Nov 2019
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(array)))
;;;
; array-default-dimensions
;
(defgeneric array-default-dimensions (contents))
(defmethod array-default-dimensions ((contents t))
(missing-method 'array-default-dimensions contents))
(defmethod-multi array-default-dimensions ((contents (number symbol string)))
(list 1))
(defmethod array-default-dimensions ((contents array))
(array-dimensions contents))
(defmethod array-default-dimensions ((contents list))
(nested-list-dimensions contents))
(defmethod array-default-dimensions ((contents dimensioned-ref-object))
(dimensions-of contents))
(defmethod array-default-dimensions ((contents scan-env))
(list t))
(defun nested-list-dimensions (nested)
(declare (type list nested))
(let ((first (first nested)))
(list* (length nested)
(if (listp first)
(nested-list-dimensions first)))))
;;;
; array-default-class-name
;
(defgeneric array-default-class-name (contents dimensions &optional deconstruct))
(defmethod array-default-class-name ((contents t) dimensions &optional deconstruct)
(declare (ignorable dimensions deconstruct)) ;(declare (ignore dimensions deconstruct)) 25JUL2023
(missing-method 'array-default-class-name contents))
;;; following moved from below 05SEP2023
(defmethod-multi array-default-class-name
((contents (symbol string)) dimensions &optional deconstruct)
(declare (ignorable dimensions deconstruct)) ;(declare (ignore dimensions deconstruct)) 25JUL2023
'ref-array)
(defmethod-multi array-default-class-name
((contents (number (eql nan) (eql infinity) (eql +infinity) (eql -infinity)))
dimensions
&optional deconstruct)
(declare (ignorable deconstruct)) ;(declare (ignore deconstruct)) 25JUL2023
(if (<= (length dimensions) 2)
'matrix
'num-array))
(defmethod-multi array-default-class-name
((contents (dimensioned-ref-object list array))
dimensions
&optional (deconstruct t))
(if deconstruct
(if (<= (length dimensions) 2)
'matrix
'num-array)
'ref-array))
(defmethod array-default-class-name ((contents scan-env)
dimensions &optional deconstruct)
(declare (ignorable deconstruct)) ;(declare (ignore deconstruct)) 25JUL2023
;; for the moment assume its numerical, until -derive is online
(if (<= (length dimensions) 2)
'matrix
'num-array))
;;; Following moved up 05SEP2023
;(defmethod-multi array-default-class-name
; ((contents (symbol string)) dimensions &optional deconstruct)
; (declare (ignorable dimensions deconstruct)) ;(declare (ignore dimensions deconstruct)) 25JUL2023
; 'ref-array)
;;;
; array-derive-class-name
;
(defgeneric array-derive-class-name (contents &optional dimensions deconstruct))
(defmethod array-derive-class-name ((contents t) &optional (dimensions :default)
(deconstruct t))
(declare (ignorable dimensions deconstruct)) ;(declare (ignore dimensions deconstruct)) 25JUL2023
(missing-method 'array-derive-class-name contents))
;;;
; array-provide-dimensions
;
(defgeneric array-provide-dimensions (dimensions contents &optional deconstruct))
(defmethod array-provide-dimensions ((dimensions t) contents &optional deconstruct)
(declare (ignorable deconstruct)) ;(declare (ignore deconstruct)) 25JUL2023
(missing-method 'array-provide-dimensions dimensions contents))
(defmethod array-provide-dimensions ((dimensions (eql :default)) contents
&optional (deconstruct t))
(declare (ignorable dimensions)) ;(declare (ignore dimensions)) 25JUL2023
(if deconstruct
(array-default-dimensions contents)
(list 1)))
(defmethod array-provide-dimensions ((dimensions (eql :default)) (contents string)
&optional (deconstruct nil))
(declare (ignorable dimensions)) ;(declare (ignore dimensions)) 25JUL2023
(if deconstruct
(list (length contents))
(list 1)))
(defmethod array-provide-dimensions ((dimensions (eql :matrix)) contents
&optional (deconstruct t))
(declare (ignorable dimensions)) ;(declare (ignore dimensions)) 25JUL2023
(if deconstruct
(subseq (full-matrix-dimensions
(array-default-dimensions contents))
0
2)
(list 1 1)))
;; following changed from fixnum to integer by Greg Anglin 93 12
;; to support Allegro port
(defmethod array-provide-dimensions ((dimensions integer) contents
&optional deconstruct)
(declare (ignorable contents deconstruct)) ;(declare (ignore contents deconstruct)) 25JUL2023
(list dimensions))
(defmethod array-provide-dimensions ((dimensions list) contents
&optional deconstruct)
(declare (ignorable contents deconstruct)) ;(declare (ignore contents deconstruct)) 25JUL2023
dimensions)
;;;
; array-provide-class-name
;
(defgeneric array-provide-class-name (class dimensions contents &optional deconstruct))
#|
;; following removed by Greg Anglin 93 12
;; to support Allegro port
(defmethod-multi array-provide-class-name ((class (keyword t)) dimensions
contents &optional deconstruct)
(declare (ignore deconstruct))
(missing-method 'array-provide-class-name class dimensions contents))
|#
(defmethod-multi array-provide-class-name ((class symbol) dimensions contents
&optional deconstruct)
(declare (ignorable contents dimensions deconstruct)) ;(declare (ignore contents dimensions deconstruct)) 25JUL2023
(if (keywordp class)
(quail-error "Unrecognized array class specifier ~S." class)
class))
(defmethod array-provide-class-name ((class (eql :default)) dimensions contents
&optional (deconstruct t))
(array-default-class-name contents dimensions deconstruct))
(defmethod-multi array-provide-class-name ((class (null (eql :derive)))
dimensions contents
&optional (deconstruct t))
(array-derive-class-name contents dimensions deconstruct))
(defmethod array-provide-class-name ((class standard-class) dimensions contents
&optional deconstruct)
(declare (ignorable dimensions contents deconstruct)) ;(declare (ignore dimensions contents deconstruct)) 25JUL2023
(class-name class))
;;;
; array
;
#| OUT 15 November 2019
#-:sbcl-linux(defgeneric array (contents &rest initargs
&key &allow-other-keys)
(:documentation
"Creates an array whose contents are given by the first argument. ~
Various methods are implemented that depend on the class of the ~
contents given. Typically the contents can be any ref'able data ~
structure like a list or an array. ~
(:required ~
(:arg contents The cell contents of the array. Usually just a list of ~
the elements, perhaps organized as a list of lists in row-major order. ~
Other possibilities include anything that is returned by array, ~
:empty to get an empty array, :default, a number, a string, or a symbol. ~
If the number of elements of the contents do not match the dimensions ~
given then array tries to fill out to an array the required dimensions ~
using the contents as elements.) ~
) ~
(:key ~
(:arg dimensions :default A list of the dimensions of the array. For example ~
a 10 by 4 matrix would have dimensions (list 10 4). ~
By default the dimensions will be inferred from the contents.) ~
(:arg class :default If given this will be the class of the array returned. ~
If :default, some effort is made to produce an appropriate return class.) ~
(:arg fill :row The major order in which the array is filled. If :row ~
then row major order is used. If :col, then column-major order.) ~
(:arg deconstruct :default If deconstruct is NIL, contents is used like an initial-element ~
ie. each element of the resulting instance is the value of contents. ~
The default value of deconstruct is NIL if source is a number, symbol, or string ~
(for speed, mostly) T otherwise.) ~
(:arg element-copy #'identity Function to be applied to each element of contents ~
that will appear in the array.) ~
(:arg type NIL No further information available.) ~
) ~
(:rest (:arg initargs NIL Other keyword value initialization arguments to be passed ~
on to the class to be created by array.))"
)
;; valid keys: dimensions class fill deconstruct element-copy type
;; future?: instance-copy element-type
)
|#
#+:aclpc-linux(excl:without-package-locks
(defgeneric array (contents &rest initargs
&key &allow-other-keys)
(:documentation
"Creates an array whose contents are given by the first argument. ~
Various methods are implemented that depend on the class of the ~
contents given. Typically the contents can be any ref'able data ~
structure like a list or an array. ~
(:required ~
(:arg contents The cell contents of the array. Usually just a list of ~
the elements, perhaps organized as a list of lists in row-major order. ~
Other possibilities include anything that is returned by array, ~
:empty to get an empty array, :default, a number, a string, or a symbol. ~
If the number of elements of the contents do not match the dimensions ~
given then array tries to fill out to an array the required dimensions ~
using the contents as elements.) ~
) ~
(:key ~
(:arg dimensions :default A list of the dimensions of the array. For example ~
a 10 by 4 matrix would have dimensions (list 10 4). ~
By default the dimensions will be inferred from the contents.) ~
(:arg class :default If given this will be the class of the array returned. ~
If :default, some effort is made to produce an appropriate return class.) ~
(:arg fill :row The major order in which the array is filled. If :row ~
then row major order is used. If :col, then column-major order.) ~
(:arg deconstruct :default If deconstruct is NIL, contents is used like an initial-element ~
ie. each element of the resulting instance is the value of contents. ~
The default value of deconstruct is NIL if source is a number, symbol, or string ~
(for speed, mostly) T otherwise.) ~
(:arg element-copy #'identity Function to be applied to each element of contents ~
that will appear in the array.) ~
(:arg type NIL No further information available.) ~
) ~
(:rest (:arg initargs NIL Other keyword value initialization arguments to be passed ~
on to the class to be created by array.))"
)
;; valid keys: dimensions class fill deconstruct element-copy type
;; future?: instance-copy element-type
))
#+:sbcl-linux(sb-ext:without-package-locks
(defgeneric array (contents &rest initargs
&key &allow-other-keys)
(:documentation
"Creates an array whose contents are given by the first argument. ~
Various methods are implemented that depend on the class of the ~
contents given. Typically the contents can be any ref'able data ~
structure like a list or an array. ~
(:required ~
(:arg contents The cell contents of the array. Usually just a list of ~
the elements, perhaps organized as a list of lists in row-major order. ~
Other possibilities include anything that is returned by array, ~
:empty to get an empty array, :default, a number, a string, or a symbol. ~
If the number of elements of the contents do not match the dimensions ~
given then array tries to fill out to an array the required dimensions ~
using the contents as elements.) ~
) ~
(:key ~
(:arg dimensions :default A list of the dimensions of the array. For example ~
a 10 by 4 matrix would have dimensions (list 10 4). ~
By default the dimensions will be inferred from the contents.) ~
(:arg class :default If given this will be the class of the array returned. ~
If :default, some effort is made to produce an appropriate return class.) ~
(:arg fill :row The major order in which the array is filled. If :row ~
then row major order is used. If :col, then column-major order.) ~
(:arg deconstruct :default If deconstruct is NIL, contents is used like an initial-element ~
ie. each element of the resulting instance is the value of contents. ~
The default value of deconstruct is NIL if source is a number, symbol, or string ~
(for speed, mostly) T otherwise.) ~
(:arg element-copy #'identity Function to be applied to each element of contents ~
that will appear in the array.) ~
(:arg type NIL No further information available.) ~
) ~
(:rest (:arg initargs NIL Other keyword value initialization arguments to be passed ~
on to the class to be created by array.))"
)
;; valid keys: dimensions class fill deconstruct element-copy type
;; future?: instance-copy element-type
)
)
#-(or :aclpc-linux :sbcl-linux)(defgeneric array (contents &rest initargs
&key &allow-other-keys)
(:documentation
"Creates an array whose contents are given by the first argument. ~
Various methods are implemented that depend on the class of the ~
contents given. Typically the contents can be any ref'able data ~
structure like a list or an array. ~
(:required ~
(:arg contents The cell contents of the array. Usually just a list of ~
the elements, perhaps organized as a list of lists in row-major order. ~
Other possibilities include anything that is returned by array, ~
:empty to get an empty array, :default, a number, a string, or a symbol. ~
If the number of elements of the contents do not match the dimensions ~
given then array tries to fill out to an array the required dimensions ~
using the contents as elements.) ~
) ~
(:key ~
(:arg dimensions :default A list of the dimensions of the array. For example ~
a 10 by 4 matrix would have dimensions (list 10 4). ~
By default the dimensions will be inferred from the contents.) ~
(:arg class :default If given this will be the class of the array returned. ~
If :default, some effort is made to produce an appropriate return class.) ~
(:arg fill :row The major order in which the array is filled. If :row ~
then row major order is used. If :col, then column-major order.) ~
(:arg deconstruct :default If deconstruct is NIL, contents is used like an initial-element ~
ie. each element of the resulting instance is the value of contents. ~
The default value of deconstruct is NIL if source is a number, symbol, or string ~
(for speed, mostly) T otherwise.) ~
(:arg element-copy #'identity Function to be applied to each element of contents ~
that will appear in the array.) ~
(:arg type NIL No further information available.) ~
) ~
(:rest (:arg initargs NIL Other keyword value initialization arguments to be passed ~
on to the class to be created by array.))"
)
;; valid keys: dimensions class fill deconstruct element-copy type
;; future?: instance-copy element-type
)
#+:aclpc-linux(excl:without-package-locks
(defmethod array ((contents t) &rest initargs
&key (dimensions :default) (class :default))
(declare (ignorable initargs dimensions class)) ;(declare (ignore initargs dimensions class)) 25JUL2023
(missing-method 'array contents)))
#+:sbcl-linux(sb-ext:without-package-locks
(defmethod array ((contents t) &rest initargs
&key (dimensions :default) (class :default))
(declare (ignorable initargs dimensions class)) ;(declare (ignore initargs dimensions class)) 25JUL2023
(missing-method 'array contents)))
#-(or :sbcl-linux :aclpc-linux)(defmethod array ((contents t) &rest initargs
&key (dimensions :default) (class :default))
(declare (ignorable initargs dimensions class)) ;(declare (ignore initargs dimensions class)) 25JUL2023
(missing-method 'array contents))
(defmethod-multi array ((contents ((eql :empty) (eql :default)))
&rest initargs
&key (dimensions :default) (class :default))
(setf dimensions (array-provide-dimensions dimensions contents))
;; use a number as contents to default to num-array when class not provided
(setf class (array-provide-class-name class dimensions 1))
(apply #'initialize-contents
class
:empty
:dimensions dimensions
initargs))
#+:aclpc-linux(excl:without-package-locks (defmethod-multi array ((contents (number symbol))
&rest initargs
&key (dimensions :default) (class :default))
(setf dimensions (array-provide-dimensions dimensions contents))
(setf class (array-provide-class-name class dimensions contents))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs)))
#+:sbcl-linux(sb-ext:without-package-locks(defmethod-multi array ((contents (number symbol))
&rest initargs
&key (dimensions :default) (class :default))
(setf dimensions (array-provide-dimensions dimensions contents))
(setf class (array-provide-class-name class dimensions contents))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs)))
#-(or :aclpc-linux :sbcl-linux)(defmethod-multi array ((contents (number symbol))
&rest initargs
&key (dimensions :default) (class :default))
(setf dimensions (array-provide-dimensions dimensions contents))
(setf class (array-provide-class-name class dimensions contents))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs))
#+:aclpc-linux (excl:without-package-locks (defmethod-multi array ((contents (dimensioned-ref-object list array scan-env))
&rest initargs
&key (dimensions :default) (class :default)
(deconstruct (not (stringp contents))))
(setf dimensions (array-provide-dimensions dimensions contents deconstruct))
(setf class (array-provide-class-name class dimensions contents deconstruct))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs)))
#+:sbcl-linux (sb-ext:without-package-locks (defmethod-multi array ((contents (dimensioned-ref-object list array scan-env))
&rest initargs
&key (dimensions :default) (class :default)
(deconstruct (not (stringp contents))))
(setf dimensions (array-provide-dimensions dimensions contents deconstruct))
(setf class (array-provide-class-name class dimensions contents deconstruct))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs)))
#-(or :aclpc-linux :sbcl-linux)(defmethod-multi array ((contents (dimensioned-ref-object list array scan-env))
&rest initargs
&key (dimensions :default) (class :default)
(deconstruct (not (stringp contents))))
;;
;; string is handled here to allow for the possibility that one might want to fill
;; a ref-array with characters, but by default it's not deconstructed.
;;
(setf dimensions (array-provide-dimensions dimensions contents deconstruct))
(setf class (array-provide-class-name class dimensions contents deconstruct))
(apply #'initialize-contents
class
contents
:dimensions dimensions
initargs))
;;;
; fill-contents
;
;; A function useful to some initialize-contents methods
;; If deconstruct is NIL, source is used like an initial-element
;; ie. each element of the resulting instance is source.
;; The default value of deconstruct is
;; NIL if source is a number, symbol, or string (for speed, mostly)
;; T otherwise
(defun fill-contents (target source &key (fill :row)
(element-copy #'identity)
(deconstruct
:default)
&allow-other-keys)
(if (eq deconstruct :default)
(setf deconstruct (not (or (numberp source) (symbolp source) (stringp source)))))
(let ((num-target (number-of-elements target))
(num-source (if deconstruct (number-of-elements source) 1))
(fill-function
(ecase fill
((:default row :row) #'row-major-eset)
((:column :col col) #'column-major-eset))))
(if deconstruct
(progn
(loop for i from 0 to (1- num-target)
do (funcall fill-function
target
i
(funcall element-copy (row-major-eref source i))))
(cond ((zerop (rem num-target num-source)) nil)
((< num-target num-source)
(warn "Filled object ~S could not contain all of the elements of ~
initializing object ~S."
target
source))
((> num-target num-source)
(warn "Number of elements in initializing object ~S does not divide evenly ~
into the number of elements of filled object ~S."
source
target))))
(loop for i from 0 to (1- num-target)
do (funcall fill-function
target
i
(funcall element-copy source))))
))
;;;
; initialize-contents
;
(defgeneric initialize-contents (ref-array init &rest initargs &key &allow-other-keys))
;; These methods for initialize-contents is responsible for making the instance,
;; and reinvoking initialize-contents on that instance.
(defmethod initialize-contents ((class symbol) (init t)
&rest initargs)
(apply #'initialize-contents (find-class class) init initargs))
(defmethod initialize-contents ((class standard-class) (init t)
&rest initargs
&key (dimensions :not-provided-is-an-error))
(declare (ignorable dimensions)) ;(declare (ignore dimensions)) 25JUL2023
(let ((new-instance (apply #'make-instance
class
:proto init
(remove-illegal-make-instance-initargs class initargs)
)))
(apply #'initialize-contents
new-instance
init
;; initargs already contains :dimensions dimensions
initargs)
new-instance))
;;;
; remove-illegal-make-instance-initargs
;
(defun remove-illegal-keys (legal-keys keyword-value-list)
(let ((len-keys (length keyword-value-list)))
(if (/= 0 (rem len-keys 2))
(quail-error "The list of keys ~S is not of even length."
keyword-value-list))
(loop for key-value on keyword-value-list
as i from 0 to (- len-keys 1)
when (and (evenp i)
(member (first key-value) legal-keys))
append (list (first key-value) (second key-value)))))
(defgeneric remove-illegal-make-instance-initargs (class initargs))
(defmethod remove-illegal-make-instance-initargs ((class-name symbol)
initargs)
(remove-illegal-make-instance-initargs (find-class class-name)
initargs))
#|
(defmethod remove-illegal-make-instance-initargs ((class standard-class)
initargs)
(if initargs
(remove-illegal-keys
#+:ccl initargs ;(ccl::class-make-instance-initargs class)
#+:(and :aclunix (not :aclpc)) (let ((legal-initargs (clos::compute-class-initargs class)))
(or legal-initargs
;; this is a bit bummed if the class *really* doesn't have
;; any initargs :-) [ or if it breaks unless it gets some ]
;; ... gotta be a better way.
(progn
(make-instance class)
(clos::compute-class-initargs class))))
initargs))
#+:aclpc initargs
initargs)
;; Version from backup to work with acl
(defmethod remove-illegal-make-instance-initargs ((class standard-class)
initargs)
#+(or :ccl (and :aclunix (not :aclpc)))
(if initargs
(remove-illegal-keys
#+:ccl (ccl::class-make-instance-initargs class)
#+(and :aclunix (not :aclpc)) (let ((legal-initargs (clos::compute-class-initargs class)))
(or legal-initargs
;; this is a bit bummed if the class *really* doesn't have
;; any initargs :-) [ or if it breaks unless it gets some ]
;; ... gotta be a better way.
(progn
(make-instance class)
(clos::compute-class-initargs class))))
initargs))
#+:aclpc initargs
)
|#
;;; version checked with acl-express-10.1, sbcl-1.4.0, ccl-1.11
(defmethod remove-illegal-make-instance-initargs ((class standard-class)
initargs)
;#+(or :ccl :sbcl-linux (and :aclunix (not :aclpc)))
(if initargs
(remove-illegal-keys
#+:ccl (ccl::class-make-instance-initargs class)
#+:aclpc-linux (excl::compute-class-initargs class)
#+:sbcl-linux (mapcar #'car (mapcar 'sb-mop:slot-definition-initargs
(sb-mop:compute-slots class)))
initargs))
#+:aclpc-mswin initargs
)
| 27,583 | Common Lisp | .l | 544 | 40.957721 | 124 | 0.635923 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 16b8c32f762483012cd417456aeb11c0a583ce65d99fd26d4db58b7398253d99 | 34,012 | [
-1
] |
34,013 | substitute-slices.lsp | rwoldford_Quail/source/quail-kernel/array/substitute-slices.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; substitute-slices.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1994 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; R.W. Oldford 1994.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(substitute-slices substitute-slices-if)))
;--------------------------------------------------------------------------------
(defun substitute-slices (old-slice new-slice ref-object
&key
(slices :elements)
(test #'ref-eq))
"Returns a copy of ref-object with slices that matched ~
old-slice according to the test function test replaced by new-slice.~
It is a non-destructive operation. If no slices matched it returns a~
copy of ref-object.~
(:see-also substitute-slices-if substitute doslices collect-slices)~
(:required ~
(:arg old-slice The old-slice to be compared to each slice in ref-object.)~
(:arg new-slice The new-slice to replace each slice matching old-slice ~
in ref-object. Note that its dimensions must match those of old-slice. ~
at least to the extent that this is required by ref itself.)~
(:arg ref-object The source of the slices which will be compared to old-slice.) ~
) ~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
(:arg test #'ref-eq The function of two arguments ~
to be called on old-slice and each slice. ~
If it returns ~
non-NIL then that slice is replaced by new-slice, otherwise it remains.)~
)~
"
(when (numberp slices) (setf slices (list slices)))
(let* (result)
;; Make the copy
(setf result (sel ref-object))
(loop for i from 0 to (- (number-of-slices result slices) 1)
when
(funcall test old-slice (column-major-ref-slice ref-object slices i))
do
(setf (column-major-ref-slice result slices i)
new-slice))
result))
(defun substitute-slices-if (new-slice pred ref-object
&key
(slices :elements))
"Returns a copy of ref-object with slices that returned non-NIL when tested ~
by the predicate function pred replaced by new-slice.~
It is a non-destructive operation. If no slices matched it returns a~
copy of ref-object.~
(:see-also substitute-slices-if substitute doslices collect-slices)~
(:required ~
(:arg new-slice The new-slice to replace each slice in ref-object satisfying ~
pred. Note that its dimensions must match those of the slice being replaced, ~
At least to the extent that this is required by ref itself.)~
(:arg pred The predicate function which tests each slice in ref-object. ~
If it returns non-NIL that slice is to be replaced, if NIL it is not.)~
(:arg ref-object The source of the slices.) ~
) ~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
)~
"
(when (numberp slices) (setf slices (list slices)))
(let* (result)
;; Make the copy
(setf result (sel ref-object))
(loop for i from 0 to (- (number-of-slices result slices) 1)
when
(funcall pred (column-major-ref-slice ref-object slices i))
do
(setf (column-major-ref-slice result slices i)
new-slice))
result))
| 5,214 | Common Lisp | .l | 108 | 41.166667 | 107 | 0.609535 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 92272846b500762a470024339c80b3e619923dc020359763e303584acc237cba | 34,013 | [
-1
] |
34,014 | copy-dispatch.lsp | rwoldford_Quail/source/quail-kernel/array/copy-dispatch.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; copy-dispatch.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1990 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1989, 1990.
;;; M.E. Lewis 1991.
;;; Greg Anglin 1993.
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
;;;
; DEFGENERIC of copy-dispatch
;
(defgeneric copy-dispatch (ref-thing thing))
;;;
; DEFMETHODs of copy-dispatch for basic classes
;
;; These methods default to getting the dimensions correct, at the expense
;; of class.
;;
;; For list, string, vector users can use :shape t to ensure they get the
;; right class at the expense of dimensions correctness.
(defmethod copy-dispatch ((proto list) ref-r)
(let* ((dim (dimensions-of ref-r)))
(if dim
(let* ((r (make-sequence 'list (first dim))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)
(eref ref-r)))) ; handles 0-dim case
(defmethod copy-dispatch ((proto string) ref-r)
(let* ((dim (dimensions-of ref-r)))
(if dim
(let* ((r (make-sequence 'string (first dim))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)
(eref ref-r)))) ; handles 0-dim case
(defmethod copy-dispatch ((proto array) ref-r)
(let* ((dim (dimensions-of ref-r)))
(let* ((r (make-array dim :element-type (array-element-type proto))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)))
;; Note: I think we don't need a method for dimensioned-ref-object, cuz proto came from
;; the ref-obj slot to begin with, see copy-ref.
(defmethod copy-dispatch ((proto ref-array) ref-r)
(let* ((dim (dimensions-of ref-r)))
(let* ((ref-obj (ref-obj-of ref-r))
(specs (specs-of ref-r))
(specs-mask (specs-mask-of ref-r)))
(convert-dim-ref-object ref-r)
(setf (ref-contents-of ref-r)
(make-array dim
:element-type (array-element-type proto)))
(copy-kernel ref-obj ref-r specs specs-mask)
ref-r)))
#|
;; Alternate versions ... troubles with 0-dim case ...
;; ... quick hack, might be wrong ... dga 92 11 03
;; ... I think this is the right separation now ... dga 93 03 20
(defmethod copy-dispatch ((proto list) ref-r)
(let* ((dim (dimensions-of ref-r)))
(let* ((r (make-list (or (first dim) 1))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)))
(defmethod copy-dispatch ((proto string) ref-r)
(let* ((dim (dimensions-of ref-r)))
(let* ((r (make-string (or (first dim) 1))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)))
(defmethod copy-dispatch ((proto array) ref-r)
(let* ((dim (dimensions-of ref-r)))
(if dim
(let* ((r (make-array dim :element-type (array-element-type proto))))
(copy-kernel (ref-obj-of ref-r) r (specs-of ref-r) (specs-mask-of ref-r))
r)
(eref ref-r)))) ; handles 0-dim case
(defmethod copy-dispatch ((proto ref-array) ref-r)
(let* ((dim (dimensions-of ref-r)))
(if dim
(let* ((ref-obj (ref-obj-of ref-r))
(specs (specs-of ref-r))
(specs-mask (specs-mask-of ref-r)))
(convert-dim-ref-object ref-r)
(setf (ref-contents-of ref-r)
(make-array dim
:element-type (array-element-type proto)))
(copy-kernel ref-obj ref-r specs specs-mask)
ref-r)
(eref ref-r)))) ; handles 0-dim case
|#
;--------------------------------------------------------------------------------
; copy-kernel is called by copy-dispatch unless the copy requires special
; attention, such as in the case of foreign arrays.
;
(defun copy-kernel (src targ specs specs-mask)
(declare (special *setf-eref*))
(let* ((marginp (listp specs))
(dim (dimensions-of targ))
(targ-num-dims (length dim))
(transformer (if marginp
#'eref-transform-of-margin
#'eref-transform-of-indices))
(current (make-sequence 'list targ-num-dims :initial-element 0))
index)
(loop for d
from 0
to (- (apply #'* dim) 1)
do (progn
(setf index (funcall transformer
(expand-list current
specs-mask
0)
specs))
(apply *setf-eref*
(apply #'eref src index)
targ
current)
(setf current (row-major-next-subscript current dim)))))
targ)
| 5,236 | Common Lisp | .l | 125 | 32.664 | 89 | 0.50997 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 3f4124cd4cbbc963c4a3138043e0b52e73a3006a5774ac0b9908afe307afa588 | 34,014 | [
-1
] |
34,015 | reduce-slices.lsp | rwoldford_Quail/source/quail-kernel/array/reduce-slices.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; reduce-slices.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1994 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; R.W. Oldford 1994.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(reduce-slices)))
;--------------------------------------------------------------------------------
(defun reduce-slices (fun ref-object
&key
(slices :elements)
(type :exterior)
(initial-value NIL init-supplied?)
(order :row)
(list? NIL))
"Combines all the slices or elements within each slice using the binary function fun. ~
Proceeds by calling fun on initial-value and the first slice or element, ~
then calling fun on the result and the next slice or element, and so on. ~
Typically, the last evaluation is returned. ~
Type :exterior means operating over slices, whereas type :interior means ~
operating over elements within slices. ~
In the latter case, reduce-slices tries to return a sensible structure for ~
the results. ~
If initial-value is not supplied then the iteration begins with the first ~
slice or element.~
(:required ~
(:arg fun A binary operator that will return a value when given two arguments.)~
(:arg ref-object The refable object over which slicing is to take place.) ~
)~
(:key ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of a ref-object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
ref-object. ~
Similarly, if slices is '(0 1) then a slice of a ref-object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the ref-object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.) ~
(:arg type :exterior The type of reduction to be performed. If type is ~
:exterior then the function is applied to pairs of slices and reduction ~
occurs over slices. If type is :interior then the function is applied to pairs ~
of elements within each slice.) ~
(:arg initial-value no-value If supplied this value will be used as the ~
first argument to the function, the first slice or element being the second. ~
If not supplied then the binary function will begin with the first slice ~
or element as its first argument and the next slice or element as its second. ~
If in this case there is only one slice so that no next slice is available ~
to be the second argument, then the function will be ~
applied as a unary function to the first slice alone.)~
(:arg order :row The order in which iteration is to take place over and within ~
slices where applicable.) ~
(:arg list? NIL If non-NIL and type is :interior the results will be returned ~
in a list. Otherwise if type is :interior the results will be returned in ~
a ref-object of the same dimensions as the slices filled according to order. ~
If type is not :interior, then list? does not apply and is ignored.) ~
)~
(:returns For :exterior type, the results of combining all slices pairwise ~
with fun. For :interior type either a ref-object of the same class as the ~
argument ref-object but with dimensions the same as its slices or a list if list?~
is non-NIL.)~
(:elaboration ~
In the current implementation, the :interior is more efficient than the :exterior ~
reduction in those cases that are comparable in function. ~
)~
(:see-also map-slices doslices collect-slices row-major-ops column-major-ops)~
(:examples (:files (Mapping functions eg:Arrays;iter-map.lisp ~
) ~
)~
)~
"
(if (eq order :col) (setf order :column))
(when (numberp slices) (setf slices (list slices)))
(cond
((eq type :exterior)
(let (result
(start 0)
(end (- (number-of-slices ref-object slices) 1)))
;; Get starting values set up.
(unless init-supplied?
(setf initial-value
(row-major-ref-slice ref-object slices start))
(incf start))
;; Now start the thing cranking
(cond
((> start end)
(funcall fun initial-value))
;; exterior row-order
((eq order :row)
(setf result
(funcall fun initial-value
(row-major-ref-slice ref-object slices start)))
(incf start)
(loop
for i from start
to end
do
(setf result
(funcall fun result
(row-major-ref-slice ref-object slices i)))
)
result)
;; exterior column-order
((eq order :column)
(setf result
(funcall fun initial-value
(column-major-ref-slice ref-object slices start)))
(incf start)
(loop
for i from start to end
do
(setf result
(funcall fun result
(column-major-ref-slice ref-object slices i))))
result)
(T
(quail-error "Illegal order given to reduce-slices -- ~s ~%~
Order must be one of (:column :row)." order)))))
((eq type :interior)
(if list?
;; then just collect them up
(if init-supplied?
(collect-slices (slice ref-object slices order)
(reduce-slices fun slice
:order order
:type :exterior
:slices :elements
:initial-value initial-value))
(collect-slices (slice ref-object slices order)
(reduce-slices fun slice
:order order
:slices :elements
:type :exterior)))
;; else try and make a structure of the same type as ref-object
;; and the same dimsneions as a single slice and stuff the results
;; in the cells.
;; The way this is now achieved is by copying a single slice
;; and filling it.
;; There has to be a more efficient way to do this
;; ******* rwo
(let ((complement-dims (iseq (length (dimensions-of ref-object))))
result)
(loop
for i in slices
do (setf complement-dims (remove i complement-dims)))
(setf result
(sel (column-major-ref-slice
ref-object
complement-dims
0)))
(cond
((eq order :row)
(if init-supplied?
(loop for i from 0 to (- (number-of-slices ref-object slices) 1)
do
(setf
(row-major-eref result i)
(reduce-slices
fun
(row-major-ref-slice ref-object slices i)
:slices :elements
:order :row
:type :exterior
:initial-value initial-value)))
(loop for i from 0 to (- (number-of-slices ref-object slices) 1)
do
(setf
(row-major-eref result i)
(reduce-slices
fun
(row-major-ref-slice ref-object slices i)
:slices :elements
:order :row
:type :exterior)))
)
result)
((eq order :column)
(if init-supplied?
(loop for i from 0 to (- (number-of-slices ref-object slices) 1)
do
(setf
(column-major-eref result i)
(reduce-slices
fun
(column-major-ref-slice ref-object slices i)
:slices :elements
:order :column
:type :exterior
:initial-value initial-value)))
(loop for i from 0 to (- (number-of-slices ref-object slices) 1)
do
(setf
(column-major-eref result i)
(reduce-slices
fun
(column-major-ref-slice ref-object slices i)
:slices :elements
:order :column
:type :exterior)))
)
result)
(T
(quail-error "Illegal order given to reduce-slices -- ~s ~%~
Order must be one of (:column :row)." order))))
)
)
)
)
| 9,515 | Common Lisp | .l | 222 | 30.977477 | 90 | 0.534038 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 03ac0c06ec67f0683843593a6dd396d4b4d63810557d4826efa1e464247a382c | 34,015 | [
-1
] |
34,016 | sort-position.lsp | rwoldford_Quail/source/quail-kernel/array/sort-position.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; sort-position.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1992 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; M.E. Lewis 1992.
;;; R.W. Oldford 1992, 1994
;;;
;;;
;;;----------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(sort-position)))
(defun sort-position (object predicate
&key
(key nil)
(slices :elements)
(type :exterior))
"Returns the position of the smallest element, ranked by predicate, ~
followed by the position of the next smallest element, etc., all ~
collected into a list.~
(:required ~
(:arg object The object whose contents are to have their sorted ~
position identified) ~
(:arg predicate A function of two arguments which returns non-NIL if and only ~
if the first argument should be considered as preceding the second.))~
(:key ~
(:arg key NIL If non-NIL this is a function that when applied to an element ~
will return ~
the key for that element. The keys are then compared by the predicate.) ~
(:arg type :exterior Two types of sort-position ~
are possible: :interior and :exterior. ~
The interior one identifies the order of ~
the elements within the specified slices and ~
the predicate should be a function that compares elements of slices.
The exterior one identifies the order of ~
the slices and not the elements within each one and ~
the predicate should be a function that compares slices.) ~
(:arg slices :elements ~
The integer or list of fixed dimensions that identifies a slice.~
For example if slices is 0 then a slice is defined to be the set of all ~
elements of object having a common value of the zeroth index. ~
There will be as many slices as the size of the zeroth dimension of the ~
object. ~
Similarly, if slices is '(0 1) then a slice of object ~
is the set of all elements ~
having common zeroth and first index and there will be as many slices ~
as there are pairs of zeroth and first indices. ~
If NIL then the whole of the object is taken to be the slice. ~
Slices may also be the keyword :elements in which case the elements ~
are accessed directly as opposed to a ref of them.)~
)~
(:returns A list, or list of lists, of sort-positions.)"
(cond ((eql type :exterior)
(if key
(mapcar #'car
(sort
(let ((i -1))
(collect-slices (slice object slices)
(cons (incf i)
(funcall key slice))))
predicate
:key #'cdr))
(mapcar #'car
(sort
(let ((i -1))
(collect-slices (slice object slices)
(cons (incf i)
slice)))
predicate
:key #'cdr))
)
)
((eql type :interior)
(collect-slices (slice object slices)
(sort-position slice predicate :slices :elements :key key :type :exterior)
))))
| 3,638 | Common Lisp | .l | 82 | 34.109756 | 86 | 0.535351 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | a90dcfd22d3984b37347139a60b8ed5da8b3864ce9b7364c359f47dca0c43cc1 | 34,016 | [
-1
] |
34,017 | mapply.lsp | rwoldford_Quail/source/quail-kernel/array/mapply.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; mapply.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1990 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1989, 1990.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(mapply)))
;--------------------------------------------------------------------------------
;;;
; DEFUN mapply
;
(defun mapply (fun &rest args)
(multiple-value-bind (dro-and-margin-list collect-scheme shape-scheme)
(interpret args '((:collect :block) (:shape :neither)))
(declare (ignore collect-scheme))
(let* ((dro-list (mapcar #'first dro-and-margin-list))
(dim-list (mapcar #'dimensions-of dro-list))
(num-dim-list (mapcar #'length dim-list))
(margin-list (get-margin-list dro-and-margin-list num-dim-list))
(margin-dim (get-margin-dim margin-list dim-list shape-scheme))
(current (make-sequence 'list (length margin-dim) :initial-element 0))
(current-to-index-map (get-current-to-index-map margin-list
margin-dim
shape-scheme))
(index-list (mapcar #'(lambda (n) (make-sequence 'list n :initial-element t))
num-dim-list))
ref-r
new-value)
(setf index-list (map-current-to-index current
index-list
current-to-index-map))
(setf new-value (apply fun (mapcar #'(lambda (x y)
(apply #'ref x y))
dro-list
index-list)))
(setf ref-r
(apply #'make-dimensioned-result
(append margin-dim
(remove 1 (dimensions-of new-value)))
(append dro-list
(list :class 'num-array)))) ;; Can this
(if (<= (length (dimensions-of ref-r)) 2) ;; be done
(change-class ref-r 'matrix)) ;; better later ?
(apply *setf-ref* new-value ref-r current)
(setf current (row-major-next-subscript current margin-dim))
(loop for d
from 1 ;; We did 0 already !!
to (- (apply #'* margin-dim) 1)
do (progn
(setf index-list (map-current-to-index current
index-list
current-to-index-map))
(setf new-value (apply fun (mapcar #'(lambda (x y)
(apply #'ref x y))
dro-list
index-list)))
(apply *setf-ref* new-value ref-r current)
(setf current (row-major-next-subscript current margin-dim))))
ref-r)))
(defun get-margin-list (dro-and-margin-list num-dim-list)
(loop for dro-and-margin in dro-and-margin-list
as num-dim in num-dim-list
collect (let* ((margin (second dro-and-margin))
(margin (if (eq margin t)
(pad-list '() num-dim t)
(pad-list margin num-dim nil)))
(m (length margin)))
(if (> m num-dim)
(quail-error "~&Margin ~S specifies ~S dimensions, but ~
object ~S has only ~S dimensions."
margin
m
(first dro-and-margin)
num-dim))
margin)))
(defun get-margin-dim (margin-list dim-list shape-scheme)
(declare (ignore shape-scheme))
(let* ((margin-dim '()))
(loop for margin in margin-list
as dim in dim-list
do (loop for m in margin
as d in dim
do (if m
(setf margin-dim (append margin-dim (list d))))))
margin-dim))
(defun get-current-to-index-map (margin-list margin-dim shape-scheme)
(declare (ignore shape-scheme))
(let* ((k 0)
(current-to-index-map (make-array (list (length margin-dim) 2))))
(loop for i from 0 to (- (length margin-list) 1)
do (let ((margin (elt margin-list i)))
(loop for j from 0 to (- (length margin) 1)
do (if (elt margin j)
(progn
(setf (aref current-to-index-map k 0) i)
(setf (aref current-to-index-map k 1) j)
(incf k))))))
current-to-index-map))
(defun map-current-to-index (current index-list current-to-index-map)
(loop for k from 0 to (- (length current) 1)
do (setf (elt (elt index-list (aref current-to-index-map k 0))
(aref current-to-index-map k 1))
(elt current k)))
index-list)
| 5,704 | Common Lisp | .l | 114 | 32.324561 | 89 | 0.424424 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | aaa87ece050f0965363fa4ec298291d0ef7701cc36e55a3ba946cd706bd3d980 | 34,017 | [
-1
] |
34,018 | sort.lsp | rwoldford_Quail/source/quail-kernel/array/sort.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; sort.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; copyright (c) 1992 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; M.E. Lewis 1992.
;;; R.W. Oldford 1992, 1994.
;;;
;;;
;;;----------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(sort)))
(defun sort (object predicate
&key
(key nil)
(slices :elements)
(type :exterior)
(copy? nil)
(stable? nil))
"Sorts the sub-arrays of slices of ref-object into an order ~
determined by predicate. For multi-dimensional objects, ~
the sorted results are stored in row-major order (last index changing ~
fastest).~
(:elaboration The arguments predicate and key are to be interpreted ~
exactly as the same named arguments in the Common Lisp sort function. ~
The argument stable? is NIL (the default) or non-NIL depending on whether ~
it is desirable that stability be guaranteed in the sense of the Common ~
Lisp function stable-sort. ~
If the argument combination permits it the sort will follow ~
the Common Lisp standard.) ~
(:see-also sort-object ~
basic-sort-by-eref cl::sort cl::stable-sort ~
sort-position ranks order) ~
(:required ~
(:arg object The object to be sorted. Typically a ref-object or sequence.) ~
(:arg predicate A function of two arguments which returns non-NIL if and only ~
if the first argument should be considered as preceding the second.))~
(:key ~
(:arg key NIL If non-NIL this is a function that when applied to an element ~
will return ~
the key for that element. The keys are then compared by the predicate.) ~
(:arg slices NIL If non-NIL, slices should be an index or list of indices ~
that identifies ~
where in the object the sorting is to take place. For example if slices ~
is 0 then a slice is defined to be the set of all elements having a common ~
zeroth index. If we also have an :interior type then this says that the elements ~
should be sorted within rows of the object. ~
If slices is the list (1 2) then a slice is the set of all elements who ~
share the same 1 and 2 indices. ~
In any case the sorting applies over all possible slices. ~
If slices is not supplied then it is assumed that every element of object will ~
be a slice.
If slices is NIL then only one slices is available, namely the object itself.)~
(:arg type :exterior Two types of sort are possible: :interior and :exterior. ~
The interior sort sorts the elements within the specified slices and ~
the predicate should be a function that compares elements of slices.
The exterior sort sorts the slices and not the elements within each one and ~
the predicate should be a function that compares slices.) ~
(:arg copy? NIL Unless this flag is non-NIL, the sort will be destructive to the ~
original object. If non-NIL, the object is copied before sorting takes place. ~
Note that for :interior type sorts this copying does not apply recursively to copy the ~
elements of the original object. So interior sorts with null slices will typically ~
be destructive to the original elements.) ~
(:arg stable? NIL If NIL, the sorting operation is not guaranteed to be stable. ~
If elements x and y are considered to be equal by the predicate as in ~
the predicate returning NIL when presented with x y in either order, ~
then there is no guarantee that the elements will stay in their original order ~
in object. ~
If stable? is non-NIL then the original order will be preserved but the sort ~
will be slower.) ~
)~
"
(when (numberp slices) (setf slices (list slices)))
(sort-object (if copy? (sel object) object)
predicate
key
slices
type
stable?)
)
| 4,326 | Common Lisp | .l | 86 | 43.604651 | 92 | 0.627483 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 1dd853ce7aad5b735d11c6bfdb27d646b0d49a333b194ad3abdb597b828561f9 | 34,018 | [
-1
] |
34,019 | glue.lsp | rwoldford_Quail/source/quail-kernel/array/glue.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; z-glue.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1990 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1989, 1990.
;;;
;;;
;;;--------------------------------------------------------------------------------
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(glue rglue cglue rglue-replicates cglue-replicates)))
;--------------------------------------------------------------------------------
(defun glue (&rest args)
(multiple-value-bind (x-list at)
(interpret args '((:at 0)))
(if x-list
(multiple-value-bind (xglue-dim at-lengths)
(glue-prep x-list at)
(glue-kernel x-list at xglue-dim at-lengths))
nil)))
(defun rglue (&rest args)
(multiple-value-bind (x-list 1d)
(interpret args '((:1d :row)))
(if x-list
(multiple-value-bind (xglue-dim at-lengths)
(glue-prep x-list 0 1d)
(glue-kernel x-list 0 xglue-dim at-lengths))
nil)))
(defun cglue (&rest args)
(multiple-value-bind (x-list 1d)
(interpret args '((:1d :col)))
(if x-list
(multiple-value-bind (xglue-dim at-lengths)
(glue-prep x-list 1 1d)
(glue-kernel x-list 1 xglue-dim at-lengths))
nil)))
;--------------------------------------------------------------------------------
;;;
; Utility functions required for glue
;
;
; glue-prep:
; Finds whether glue will work along axis at, and signals an error if not.
; Returns multiple values:
;
; 1. xglue-dim, the dimensions which the object returned by glue will have
; 2. at-lengths, the added length along the at axis for each x in x-list
;
(defun glue-prep (x-list at &optional one-dim)
(let* ((x-num (length x-list))
(dim-list (mapcar #'dimensions-of x-list))
(len-list (mapcar #'length dim-list))
(n (apply #'max len-list))
(xglue-dim nil)
(at-lengths nil))
(if (and one-dim (<= n 2))
(progn
(loop for i
from 0
to (- x-num 1)
do (case (elt len-list i)
(0 (setf (elt len-list i) 2)
(setf (elt dim-list i) '(1 1)))
(1 (setf (elt len-list i) 2)
(setf (elt dim-list i)
(ecase one-dim
(:row (list* 1 (elt dim-list i)))
(:col (append (elt dim-list i) (list 1))))))))
(setf n (apply #'max len-list))))
(if (> at n)
(quail-error "Improperly specified :at parameter ~S." at))
(if (= at n)
(if (all-equal dim-list)
(progn
(setf xglue-dim (append (first dim-list) (list x-num)))
(setf at-lengths (make-sequence 'list x-num :initial-element 1)))
(glue-prep-error at))
(let* ((at-mask (loop for i
from 0
to (- n 1)
collect (/= i at)))
(pos-n (position n len-list))
(dim-proto (list-if-t (elt dim-list pos-n) at-mask)))
; (format *quail-terminal-io*
; "~&n ~S at-mask ~S dim-proto ~S"
; n at-mask dim-proto)
(setf at-lengths
(loop for i
from 0
to (- x-num 1)
collect (let* ((dim (elt dim-list i))
(len (elt len-list i))
(dim-mask nil)
(at-length nil))
(cond ((eq n len)
(setf dim-mask (list-if-t dim at-mask))
(setf at-length (elt dim at)))
((eq (- n 1) len)
(setf dim-mask dim)
(setf at-length 1))
(t (glue-prep-error at)))
; (format *quail-terminal-io*
; "~&i ~S dim ~S len ~S dim-mask ~S at-length ~S"
; i dim len dim-mask at-length)
(if (equal dim-proto dim-mask)
at-length
(glue-prep-error at)))))
(setf xglue-dim (append (subseq dim-proto 0 at)
(list (apply #'+ at-lengths))
(subseq dim-proto at)))))
(values xglue-dim at-lengths)))
(defun glue-prep-error (at)
(quail-error "Cannot glue given objects along axis ~S." at))
; glue-kernel:
; creates and returns xglue as glue of elements of x-list along axis at.
(defun glue-kernel (x-list at xglue-dim at-lengths)
(let* ((xglue (apply #'make-dimensioned-result xglue-dim x-list))
(x-num (length x-list))
(ref-indices (make-sequence 'list (length xglue-dim) :initial-element t))
(at-current 0))
(loop for i
from 0
to (- x-num 1)
do (let ((x-at-length (elt at-lengths i)))
(glue-setf-kernel xglue
ref-indices
at
at-current
(elt x-list i)
x-at-length)
(setf at-current (+ at-current x-at-length))))
xglue))
; glue-setf-kernel
; destructively setf's x into xglue along at axis from at-current for x-at-length
(defun glue-setf-kernel (xglue ref-indices at at-current x x-at-length)
(setf (elt ref-indices at) (iseq at-current (+ at-current x-at-length -1)))
(apply *setf-ref* x xglue ref-indices))
;--------------------------------------------------------------------------------
(defun rglue-replicates (num-row row &rest other-involved-objects)
(let* ((row-dim (dimensions-of row))
(num-row-dim (length row-dim))
(num-col (first row-dim))
(result (apply #'make-dimensioned-result (list num-row num-col)
row
other-involved-objects)))
(ecase num-row-dim
(1
(loop for j from 0 to (- num-col 1)
do (let ((element (eref row j)))
(loop for i from 0 to (- num-row 1)
do (setf (eref result i j) element)))))
(2
(loop for j from 0 to (- num-col 1)
do (let ((element (eref row j 0)))
(loop for i from 0 to (- num-row 1)
do (setf (eref result i j) element))))))
result))
(defun cglue-replicates (num-col col &rest other-involved-objects)
(let* ((col-dim (dimensions-of col))
(num-col-dim (length col-dim))
(num-row (first col-dim))
(result (apply #'make-dimensioned-result (list num-row num-col)
col
other-involved-objects)))
(ecase num-col-dim
(1
(loop for i from 0 to (- num-row 1)
do (let ((element (eref col i)))
(loop for j from 0 to (- num-col 1)
do (setf (eref result i j) element)))))
(2
(loop for i from 0 to (- num-row 1)
do (let ((element (eref col i 0)))
(loop for j from 0 to (- num-col 1)
do (setf (eref result i j) element))))))
result))
| 8,163 | Common Lisp | .l | 182 | 30.489011 | 119 | 0.427166 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 596bbba3996d4bdad1285837f344cf010a091bba536deaa81ce3719cd449dfb3 | 34,019 | [
-1
] |
34,020 | rlog | rwoldford_Quail/source/quail-kernel/array/rlog |
RCS file: RCS/accumulate.lisp,v
Working file: accumulate.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/adjust-array.lisp,v
Working file: adjust-array.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/array.lisp,v
Working file: array.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/27 23:21:32; author: dganglin; state: Exp; lines: +12 -3
Misc fixes (during Quaff port)
----------------------------
revision 1.2
date: 1994/02/15 16:42:07; author: rwoldford; state: Exp; lines: +34 -0
Added documentation to the array generic function.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/collapse.lisp,v
Working file: collapse.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +68 -46
*** empty log message ***
----------------------------
revision 1.2
date: 1994/03/01 15:20:07; author: rwoldford; state: Exp; lines: +77 -74
Completely rewrote collapse to take slices argument and order.
THis brings it in line with other slice mapping functions.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/copy-dispatch.lisp,v
Working file: copy-dispatch.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/count-slices.lisp,v
Working file: count-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provides facility like the sequence count and count-if for ref-objects.
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +30 -8
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:10:07; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/doodles.lisp,v
Working file: doodles.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/file-matrix.lisp,v
Working file: file-matrix.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/10/27 17:42:09; author: rwoldford; state: Exp; lines: +2 -1
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/find-slices.lisp,v
Working file: find-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provides facility like the sequence find and find-if for ref-objects
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +36 -14
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:11:26; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/glue.lisp,v
Working file: glue.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/init-return-classes.lisp,v
Working file: init-return-classes.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/map-element.lisp,v
Working file: map-element.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/07/21 21:09:25; author: dganglin; state: Exp; lines: +16 -11
Fixed dimensions problem when first thing is scalar or #0m(..)
and later things all have exactly one element. Now returns
biggest dimensions as expected.
----------------------------
revision 1.2
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +24 -4
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/map-slices.lisp,v
Working file: map-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provides map-element like facility for slices of a ref-object
Together map-element and map-slices allow mapping over ref objects very much
like map does for sequences.
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +15 -3
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:12:13; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/mapply.lisp,v
Working file: mapply.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +1 -1
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/matrix.lisp,v
Working file: matrix.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/mk-array.lisp,v
Working file: mk-array.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/27 23:22:43; author: dganglin; state: Exp; lines: +38 -30
deprecated make-ref-array
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/num-array.lisp,v
Working file: num-array.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/10/27 17:45:54; author: rwoldford; state: Exp; lines: +2 -1
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/ones-array.lisp,v
Working file: ones-array.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +12 -1
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/order.lisp,v
Working file: order.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +48 -21
*** empty log message ***
----------------------------
revision 1.2
date: 1994/02/17 21:25:28; author: rwoldford; state: Exp; lines: +26 -11
Updated doc string.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/ranks.lisp,v
Working file: ranks.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +22 -18
*** empty log message ***
----------------------------
revision 1.2
date: 1994/02/17 21:26:01; author: rwoldford; state: Exp; lines: +27 -7
Updated doc string
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/reduce-slices.lisp,v
Working file: reduce-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Reduce-slices is a lot like the CL reduce function but for
multi-way ref-objects.
It completely replaces the old QUail function accumulate.
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +33 -14
*** empty log message ***
----------------------------
revision 1.1
date: 1994/03/01 15:18:04; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/ref-array.lisp,v
Working file: ref-array.lisp
head: 1.2
branch:
locks: strict
dganglin: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: dganglin;
date: 1994/03/27 23:21:32; author: dganglin; state: Exp; lines: +4 -3
Misc fixes (during Quaff port)
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/remove-slices.lisp,v
Working file: remove-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provides facility like the sequence remove ande remove-if functions
for ref-objects.
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +12 -4
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:14:20; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/replace-slices.lisp,v
Working file: replace-slices.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/slice-positions.lisp,v
Working file: slice-positions.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provides ref-objects with a function much like the sequence functions
position and position-if
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +34 -12
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:15:04; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/slice.lisp,v
Working file: slice.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Initial check in
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +121 -60
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/sort-object.lisp,v
Working file: sort-object.lisp
head: 1.5
branch:
locks: strict
rwoldford: 1.5
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
Initial check in
----------------------------
revision 1.5 locked by: rwoldford;
date: 1994/06/16 17:51:43; author: rwoldford; state: Exp; lines: +1 -0
Balanced parens in the sort-object docs.
----------------------------
revision 1.4
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +21 -9
*** empty log message ***
----------------------------
revision 1.3
date: 1994/02/24 21:19:01; author: rwoldford; state: Exp; lines: +1 -1
Fixed miscellaneous bugs.
----------------------------
revision 1.2
date: 1994/02/17 21:26:55; author: rwoldford; state: Exp; lines: +61 -25
Cleaned up considerably. Making :exterior the default
And rationalized :interior sorts.
Now :interior and :exterior with null slices no longer do the same thing.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/sort-position.lisp,v
Working file: sort-position.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +22 -20
*** empty log message ***
----------------------------
revision 1.2
date: 1994/02/17 21:31:58; author: rwoldford; state: Exp; lines: +29 -8
:exterior is now default type
Documentation string expanded.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/sort.lisp,v
Working file: sort.lisp
head: 1.3
branch:
locks: strict
rwoldford: 1.3
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
Initial check in
----------------------------
revision 1.3 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +21 -21
*** empty log message ***
----------------------------
revision 1.2
date: 1994/02/17 21:26:28; author: rwoldford; state: Exp; lines: +48 -25
updated doc string.
----------------------------
revision 1.1
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
RCS file: RCS/substitute-slices.lisp,v
Working file: substitute-slices.lisp
head: 1.2
branch:
locks: strict
rwoldford: 1.2
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
Provide ref-objects with facility for substituting arbitrary slices
much like the sequence functions substitute and substitute-if
----------------------------
revision 1.2 locked by: rwoldford;
date: 1994/03/08 18:04:44; author: rwoldford; state: Exp; lines: +31 -9
*** empty log message ***
----------------------------
revision 1.1
date: 1994/02/24 21:16:27; author: rwoldford; state: Exp;
Initial revision
=============================================================================
RCS file: RCS/tp.lisp,v
Working file: tp.lisp
head: 1.1
branch:
locks: strict
rwoldford: 1.1
access list:
symbolic names:
comment leader: ";;; "
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Initial check in
----------------------------
revision 1.1 locked by: rwoldford;
date: 1994/02/03 19:16:56; author: dganglin; state: Exp;
Initial check in
=============================================================================
| 21,163 | Common Lisp | .l | 698 | 28.183381 | 78 | 0.585698 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 4705db9c16500dc28b4a83566b28456c8d5bf8c3398fa7e920d529898d9157ed | 34,020 | [
-1
] |
34,021 | ones-array.lsp | rwoldford_Quail/source/quail-kernel/array/ones-array.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; ones-array.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (C) 1994 Statistical Computing Laboratory, University Of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1993?
;;; R.W. Oldford 1994.
;;;
;;;--------------------------------------------------------------------------------
(in-package :qk)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(ones-array ones-matrix ones)))
(defclass ones-array (num-array)
()
(:documentation "An array of 1s. (:see-also (ones-matrix :class) ~
(ones :function)) ")
)
(defmethod initialize-instance :after ((r ones-array) &rest initargs)
(declare (ignore initargs))
(setf (ref-contents-of r) 1))
(defmethod eref ((self ones-array) &rest index)
(eref-true-index self index)
;; if no error ...
1)
(defmethod (setf eref) (new-value (self ones-array) &rest index)
(declare (ignore new-value index))
(quail-error "~&Can't setf an element of an array of class ~S."
(class-name (class-of self))))
(defclass ones-matrix (matrix ones-array)
()
(:documentation "A matrix of 1s. ~
(:see-also (ones-array :class) ~
(ones :function)) ")
)
(defmethod initialize-instance :after ((r ones-matrix) &rest initargs)
(declare (ignore initargs))
(setf (ref-contents-of r) 1))
(defmethod eref ((self ones-matrix) &rest index)
(eref-true-index self index)
;; if no error ...
1)
(defmethod (setf eref) (new-value (self ones-matrix) &rest index)
(declare (ignore new-value index))
(quail-error "~&Can't setf an element of an array of class ~S."
(class-name (class-of self))))
(defun ones (n &rest other-dimensions)
"Create an array full of ones whose elements are constant. ~
(:required~
(:arg n The first dimension of the array.)) ~
(:rest ~
(:arg other-dimensions NIL The remaining dimensions of the array ~
of ones.))~
(:elaboration This is an array of constants. Its contents cannot be changed ~
and every element is the fixnum 1.)"
(cond
((null other-dimensions)
(make-instance 'ones-matrix :dimensions (list n)))
((= 1 (length other-dimensions))
(make-instance 'ones-matrix :dimensions (list n (first other-dimensions))))
(T
(make-instance 'ones-array :dimensions (append (list n) other-dimensions)))
)
)
(put-return-class 'num-array 'ones-array
'(ones-array matrix num-array
array vector cons number integer fixnum float
rational complex symbol))
(put-return-class 'num-array 'ones-matrix
'(ones-array num-array))
(put-return-class 'matrix 'ones-matrix
'(matrix array vector cons number integer fixnum float
rational complex symbol))
| 3,098 | Common Lisp | .l | 77 | 33.636364 | 96 | 0.564025 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 7c0c013839cb2bbc80e32672b9a3a8a0f80b97f03a5e4df7c17a5f7e695b5fac | 34,021 | [
-1
] |
34,022 | tp.lsp | rwoldford_Quail/source/quail-kernel/array/tp.lsp | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; tp.lisp
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;
;;; Copyright (c) 1990 Statistical Computing Laboratory, University of Waterloo
;;;
;;;
;;; Authors:
;;; Greg Anglin 1989, 1990.
;;; R.W. Oldford 1991.
;;; M.E. Lewis 1991.
;;;
;;;
;;;--------------------------------------------------------------------------------
;;;
;;; Includes:
;;; tp
;;; tp-dispatch
;;;
(in-package :quail-kernel)
(eval-when (:compile-toplevel :load-toplevel :execute) (export '(tp)))
;--------------------------------------------------------------------------------
;;;
; DEFGENERIC for tp
;
(defgeneric tp (r &key perm)
(:documentation "A generalized transpose operator.")
)
;--------------------------------------------------------------------------------
;;;
; Utility functions required for tp method
;
(defun tp-will-work (r perm)
(let* ((dim (dimensions-of r))
(len (length dim))
(unperm (iseq len))
(will-work (equal unperm (sort (ref-list perm) #'<))))
(if will-work
t
(tp-error r perm))))
(defun tp-setf-kernel (rtp r perm) ; destructively sets rtp to tp of r
(declare (special *setf-eref*))
(let* ((dim (dimensions-of r))
(len (length dim))
(current (make-sequence 'list (length dim) :initial-element 0)))
(loop for d
from 0
to (- (apply #'* dim) 1)
do (let* ((indices (perm-indices current perm len)))
(apply *setf-eref*
(apply #'eref r current)
rtp
indices)
(setf current (row-major-next-subscript current dim))))))
(defun perm-indices (current perm len)
(loop for i
from 0
to (- len 1)
collect (elt current (elt perm i))))
(defun tp-dispatch (r perm)
(let* ((dim (dimensions-of r))
(len (length dim)))
(if (not perm)
(if (eq len 1)
(setf perm '(1 0))
(setf perm (reverse (iseq len)))))
(cond ((and (eq len 1) (equal perm '(1 0)))
(let ((cv (make-dimensioned-result (list 1 (first dim)) r)))
(setf (ref cv) r)
cv))
((and (eq len 1) (equal perm '(0)))
r)
((and (eq len 0) (not perm))
r)
((tp-will-work r perm) ; this case traps errors
(let* ((dim (dimensions-of r))
(tp-r (make-dimensioned-result
(perm-indices dim perm len)
r)))
(tp-setf-kernel tp-r r perm)
tp-r)))))
(defun tp-error (r perm)
(let ((len (length (dimensions-of r))))
(quail-error "Second argument to tp must be a permutation of 0 through ~S, ~
~&since ~S has ~S dimensions. ~
~&Provided argument ~S is not such a permutation."
(- len 1)
r
len
perm)))
;;;
; DEFMETHODs of tp
;
(defmethod tp ((self number) &key (perm NIL))
(if (not perm)
self
(tp-error self perm)))
(defmethod tp ((self (eql NaN)) &key perm)
(if (not perm)
self
(tp-error self perm)))
(defmethod tp ((self (eql +infinity)) &key perm)
(if (not perm)
self
(tp-error self perm)))
(defmethod tp ((self (eql -infinity)) &key perm)
(if (not perm)
self
(tp-error self perm)))
(defmethod tp ((self list) &key perm)
(if (not perm)
(setf perm '(1 0)))
(cond ((equal perm '(0)) self)
((equal perm '(1 0)) (make-array (list 1 (length self))
:initial-contents (list self)))
(t (tp-error self perm))))
(defmethod tp ((self array) &key perm)
(tp-dispatch self perm))
(defmethod tp ((self ref-array) &key perm)
(tp-dispatch self perm))
(defmethod tp ((self t) &key perm)
(missing-method 'tp self perm))
| 4,206 | Common Lisp | .l | 125 | 25.696 | 84 | 0.456053 | rwoldford/Quail | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 09b365c8ae52cafcf7d83c3b8f0104e65f52927e6746192fa0f53e0772d17386 | 34,022 | [
-1
] |
35,064 | package.lisp | TurtleWarePL_clest/package.lisp | ;;;; package.lisp
(defpackage #:clest
(:use #:cl #:alexandria)
;; Protocol
(:export #+(or)classes
#:project
#:test-suite
#:test-scenario
#:test-case
;; conditions
#:clest-error
#:child-already-exists
#:child-doesnt-exist
#:invalid-designator
#:invalid-parent-type
;; project protocol
#:make-project
#:extensions
;; test suite protocol
#:make-test-suite
;; test scenario protocol
#:make-test-scenario
;; test case protocol
#:make-test-case
;; synopsis protocol
#:name
#:description
;; test tree protocol
#:list-children
#:save-child
#:load-child
#:delete-child
;; #:testing-plan #:make-testing-plan
;; #:build #:make-build
)
;; Default implementation
(:export #:basic-project
#:basic-test-suite
#:basic-test-scenario))
| 1,090 | Common Lisp | .lisp | 39 | 17.641026 | 49 | 0.491429 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | c6ebba410cdae6416b6cc80ac5dbb4d2b5c64af05b54771101a5fb9e52e46d5b | 35,064 | [
-1
] |
35,065 | clest.lisp | TurtleWarePL_clest/clest.lisp | ;;;; clest.lisp
(in-package #:clest)
(defmacro define-protocol-class (name &optional super &rest args)
`(progn
(defclass ,name ,super () ,@args)
(defgeneric ,(symbolicate 'make- name)
(type &rest initargs &key name &allow-other-keys)
(:method ((type (eql ',name)) &key name)
(declare (ignore type name))
(error "Protocol class ~s can't be instantiated." ',name)))))
(define-modify-macro togglef () not)
;;; Mixins
(defclass name-desc-mixin ()
((name :initform (error "Name is mandatory for this object.")
:initarg :name
:type 'string
:accessor name)
(desc :initform nil
:initarg :description
:accessor description)))
(defclass tree-parent-mixin (name-desc-mixin)
((children :initform (make-hash-table :test #'equal)
:initarg :children
:type 'hash-table
:accessor %children)))
(defclass tree-leaf-mixin (name-desc-mixin) ())
(defclass project-parent-mixin (tree-parent-mixin) ())
(defgeneric list-children (parent))
(defgeneric save-child (parent object))
(defgeneric load-child (parent name))
(defgeneric delete-child (parent name))
(defmethod list-children ((object tree-parent-mixin))
(hash-table-values (%children object)))
(defmethod list-children ((object tree-leaf-mixin))
nil)
(defmethod list-children ((object hash-table))
(hash-table-values object))
(defmethod save-child ((parent tree-parent-mixin) object)
(if-let ((child #1=(gethash (name object) (%children parent))))
(error 'clest:child-already-exists :parent parent :child child :object object)
(setf #1# object)))
(defmethod load-child ((parent tree-parent-mixin) (name string))
(or (gethash name (%children parent) )
(error 'clest:child-doesnt-exist :parent parent :name name)))
(defmethod delete-child ((parent tree-parent-mixin) (name string))
(or (remhash name (%children parent))
(error 'clest:child-doesnt-exist :parent parent :name name)))
| 2,000 | Common Lisp | .lisp | 47 | 37.617021 | 82 | 0.684564 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 73bd09d9f74e8ca5170ec35ef7ba1b0104cd9081bb521f5a0cc0a54ad242c0fa | 35,065 | [
-1
] |
35,066 | tree-gadget.lisp | TurtleWarePL_clest/interface/tree-gadget.lisp | (in-package #:clest)
(defclass abstract-tree-gadget (clim:basic-gadget)
((root :initarg :root
:initform (error ":root argument is obligatory.")
:reader tree-root)))
(defclass generic-tree-gadget (abstract-tree-gadget climi::always-repaint-background-mixin)
((expanded :initform (make-hash-table) :reader expanded)
(buttons :initform (make-instance 'clim:standard-sequence-output-record)
:accessor buttons)
(max-x :initform 250 :accessor max-x)
(max-y :initform 60 :accessor max-y))
(:default-initargs :text-style (clim:make-text-style :fixed nil :normal)))
(defclass node-output-record (climi::basic-output-record)
((node :initarg :node :reader node)))
(defun toggle-node (gadget node)
(togglef (gethash node (expanded gadget))))
(defun expandedp (gadget node)
(gethash node (expanded gadget)))
(defmethod initialize-instance :after ((record node-output-record)
&key x1 y1 x2 y2)
(setf (clim:rectangle-edges* record)
(values x1 y1 x2 y2)))
(defmethod clim:compose-space ((pane generic-tree-gadget) &key width height)
(declare (ignorable width height))
(with-slots (max-x max-y) pane
(clim:make-space-requirement :min-width max-x :min-height max-y
:max-width max-x :max-height max-y
:width max-x :height max-y)))
(defmethod clim:handle-repaint ((gadget generic-tree-gadget) region)
(declare (ignore region))
(clim:clear-output-record (buttons gadget))
(let (current-y current-x button-width button-height)
(setf (values button-width button-height) (clim:text-size gadget " ")
(values current-x current-y (max-x gadget) (max-y gadget)) (values 0 0 220 50))
(labels ((present-node (node)
(let ((text (if (clest:list-children node)
(if (expandedp gadget node)
(format nil " - ~A" (clest::name node))
(format nil " + ~A" (clest::name node)))
(format nil " ~A" (clest::name node)))))
(clim:draw-text* gadget text current-x current-y :align-y :top)
(when-let ((ch (clest:list-children node))
(x1 current-x)
(y1 current-y)
(x2 (+ current-x button-width))
(y2 (+ current-y button-height)))
(clim:draw-rectangle* gadget x1 y1 x2 y2 :filled nil :ink clim:+darkred+)
(clim:add-output-record (make-instance 'node-output-record
:node node :x1 x1 :y1 y1 :x2 x2 :y2 y2)
(buttons gadget)))
(multiple-value-bind (text-width text-height)
(clim:text-size gadget text)
(incf current-y text-height)
(maxf (slot-value gadget 'max-y) current-y)
(maxf (slot-value gadget 'max-x) (+ current-x text-width)))
(when (expandedp gadget node)
(incf current-x 20)
(dolist (c (clest:list-children node))
(present-node c))
(decf current-x 20)))))
(dolist (c (clest:list-children (tree-root gadget)))
(present-node c))))
(clim:change-space-requirements gadget))
(defmethod clim:handle-event ((gadget generic-tree-gadget)
(event clim:pointer-button-press-event))
(clim:map-over-output-records-containing-position
#'(lambda (record)
(toggle-node gadget (node record))
(clim:handle-repaint gadget clim:+everywhere+)
(return-from clim:handle-event nil))
(buttons gadget)
(clim:pointer-event-x event)
(clim:pointer-event-y event)))
| 3,905 | Common Lisp | .lisp | 73 | 40.027397 | 97 | 0.572325 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 7036d54f14aceacc7045537422274548587a939f0c20c3fe4971ae1219cb17cb | 35,066 | [
-1
] |
35,067 | application-frame.lisp | TurtleWarePL_clest/interface/application-frame.lisp | (in-package #:clest)
(eval-when (:compile-toplevel :load-toplevel :execute)
(clim:define-presentation-type foobar ()))
(defgeneric display (frame pane)
(:method (frame pane)
(declare (ignore frame))
(clim:with-output-as-presentation (pane "foobar" 'foobar)
(format pane "Foobar 1.~%"))
(format pane "No display method defined.~%")))
(clim:define-application-frame clest (clim:standard-application-frame
project-parent-mixin)
((tree-type :initarg :tree))
(:geometry :width 800 :height 1600)
(:pane (clim:make-pane (slot-value clim:*application-frame* 'tree-type)
:root clim:*application-frame*))
(:menu-bar nil))
(defun run-ui (&optional (tree 'generic-tree-gadget))
(setf *projects* (clim:make-application-frame 'clest :tree tree))
(clest/unit-tests::populate-data 'basic-project
'basic-test-suite
'basic-test-scenario
'basic-test-case
*projects*)
(clim:run-frame-top-level *projects*))
| 1,130 | Common Lisp | .lisp | 24 | 35.958333 | 73 | 0.594374 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | ed649f032981faccac22e19edaa88f95eb7bdccad5b5e6d73e865c5cd5d1097b | 35,067 | [
-1
] |
35,068 | unit-tests.lisp | TurtleWarePL_clest/tests/unit-tests.lisp | (defpackage #:clest/unit-tests
(:use #:cl #:1am)
(:export #:run-tests))
(in-package #:clest/unit-tests)
(defun run-tests (&optional
(project-class 'clest:basic-project)
(test-suite-class 'clest:basic-test-suite)
(test-scenario-class 'clest:basic-test-scenario)
(test-case-class 'clest::basic-test-case))
(let ((clest::*projects* (make-hash-table :test #'equal)))
(populate-data project-class test-suite-class test-scenario-class test-case-class)
(let* ((project (test-project-protocol project-class))
(test-suite (test-test-suite-protocol test-suite-class :parent project))
(test-scenario (test-test-scenario-protocol test-scenario-class :parent test-suite))
(test-case (test-test-case-protocol test-case-class :parent test-scenario)))
(is (typep project 'clest:project))
(is (typep test-suite 'clest:test-suite))
(is (typep test-scenario 'clest:test-scenario))
(is (typep test-case 'clest:test-case))
clest::*projects*)))
(defun populate-data (project-class test-suite-class test-scenario-class test-case-class
&optional parent)
(let ((parent (clest:make-project project-class :name "Common Lisp Tests Go East" :parent parent)))
(clest:make-test-suite test-suite-class :parent parent :name "Building and Deployment")
(clest:make-test-suite test-suite-class :parent parent :name "Test suite managament")
(clest:make-test-suite test-suite-class :parent parent :name "Testing plan managament")
(clest:make-test-suite test-suite-class :parent parent :name "User Interface")
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Backend")))
(clest:make-test-suite test-suite-class :parent parent :name "REST API")
(clest:make-test-suite test-suite-class :parent parent :name "Unit Tests"))
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Reports")))
(clest:make-test-scenario test-scenario-class :parent parent :name "Make report")
(clest:make-test-scenario test-scenario-class :parent parent :name "Remove report"))
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Documentation")))
(clest:make-test-suite test-suite-class :parent parent :name "User manual")
(clest:make-test-suite test-suite-class :parent parent :name "Requirement managament")
(clest:make-test-scenario test-scenario-class :parent parent :name "Ensure completeness")
(clest:make-test-scenario test-scenario-class :parent parent :name "Ensure correctness")))
(let ((parent (clest:make-project project-class :name "McCLIM" :parent parent)))
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Output Records")))
(clest:make-test-suite test-suite-class :parent parent :name "Composite")
(clest:make-test-suite test-suite-class :parent parent :name "Display")
(clest:make-test-suite test-suite-class :parent parent :name "Logical"))
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Sheets")))
(clest:make-test-suite test-suite-class :parent parent :name "Panes")
(clest:make-test-suite test-suite-class :parent parent :name "Gadgets")
(clest:make-test-suite test-suite-class :parent parent :name "Streams"))
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Presentations")))
(clest:make-test-suite test-suite-class :parent parent :name "Methods")
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Application")))
(clest:make-test-suite test-suite-class :parent parent :name "Input")
(clest:make-test-suite test-suite-class :parent parent :name "Dragging"))
(clest:make-test-suite test-suite-class :parent parent :name "Translators")))
(clest:make-project project-class :name "Sandbox Project" :parent parent)
(let ((parent (clest:make-project project-class :name "Embeddable Common-Lisp" :parent parent)))
(clest:make-test-suite test-suite-class :parent parent :name "Deployment")
(let ((parent (clest:make-test-suite test-suite-class :parent parent :name "Compilation")))
(clest:make-test-suite test-suite-class :parent parent :name "Bytecodes compiler")
(clest:make-test-suite test-suite-class :parent parent :name "Native compiler")
(clest:make-test-suite test-suite-class :parent parent :name "Environments")))
(let ((parent (clest:make-project project-class :name "Test Project X" :parent parent)))
(dotimes (v 3)
(let ((parent (clest:make-test-suite test-suite-class
:parent parent
:name (format nil "Test Suite ~s" (1+ v)))))
(dotimes (v 2)
(let ((parent (clest:make-test-suite test-suite-class
:parent parent
:name (format nil "(Sub-)Test Suite ~s" (1+ v)))))
#1=(dotimes (v 2)
(let ((parent (clest:make-test-scenario
test-scenario-class
:parent parent
:name (format nil "Test Scenario ~s" (1+ v)))))
(dotimes (v 3)
(clest:make-test-case
test-case-class
:parent parent
:name (format nil "Test Case ~s" (1+ v))))))))
#1#))))
(defun test-project-protocol (project-class &key parent
&aux (len (length (clest:list-children parent))))
"Tests project protocol. Returns created project \"UT Foobar Project\" (with no children)."
;; 1. MAKE-PROJECT with name not being a string
(signals clest:invalid-designator (clest:make-project project-class :name 3 :parent parent))
(signals clest:invalid-designator (clest:make-project project-class :name :xxx :parent parent))
;; 2. MAKE-PROJECT with valid parent
(clest:make-project project-class :name "UT Foobar Project" :parent parent)
(is (= (1+ len) (length (clest:list-children parent))))
;; 3. MAKE-PROJECT twice with the same name
(signals clest:child-already-exists
(clest:make-project project-class :name "UT Foobar Project" :parent parent))
;; 4. LOAD-CHILD non-existing project from PARENT
(signals clest:child-doesnt-exist (clest:load-child parent "UT Quxbar Project"))
;; 5. LOAD-CHILD existing project from PARENT (ensure protocol class)
(is (typep (clest:load-child parent "UT Foobar Project") 'clest:project))
;; 6. DELETE-CHILD existing project from PARENT
(clest:delete-child parent "UT Foobar Project")
(is (= len (length (clest:list-children parent))))
;; 7. DELETE-CHILD twice existing project from PARENT
(signals clest:child-doesnt-exist (clest:delete-child parent "UT Foobar Project"))
;; 8. DELETE-CHILD non-existing project from PARENT
(signals clest:child-doesnt-exist (clest:delete-child parent "UT Quxbar Project"))
;; return project we can use in further tests
(clest:make-project project-class :name "UT Foobar Project" :parent parent))
(defun test-test-suite-protocol (test-suite-class &key parent)
;; Adding new test suites
(is (null (clest:list-children parent)))
(let ((ts1 (clest:make-test-suite test-suite-class :name "TestSuite1" :parent parent))
(ts2 (clest:make-test-suite test-suite-class :name "TestSuite2" :parent parent)))
(signals error
(clest:make-test-suite test-suite-class :name :test-suite-3 :parent parent))
(signals error
(clest:make-test-suite test-suite-class :name "TestSuite1" :parent parent))
(is (= (length (clest:list-children parent)) 2))
;; Adding sub-test suites
(clest:make-test-suite test-suite-class :name "TestSuite1" :parent ts1)
(clest:make-test-suite test-suite-class :name "TestSuite2a" :parent ts2)
(is (= (length (clest:list-children parent)) 2))
(is (= (length (clest:list-children ts1)) 1))
(is (= (length (clest:list-children ts2)) 1))
;; Removing test-suites
(clest:delete-child ts1 "TestSuite1")
(clest:delete-child parent "TestSuite2")
(is (= (length (clest:list-children parent)) 1))
(is (= (length (clest:list-children ts1)) 0))
(is (= (length (clest:list-children ts2)) 1))
ts1))
(defun test-test-scenario-protocol (test-scenario-class &key parent)
;; Adding new test scenarios
(let ((no (length (clest:list-children parent)))
(ts1 (clest:make-test-scenario test-scenario-class :name "TestScenario1" :parent parent))
(ts2 (clest:make-test-scenario test-scenario-class :name "TestScenario2" :parent parent)))
(signals error
(clest:make-test-scenario test-scenario-class :name :test-suite-3 :parent parent))
(signals error
(clest:make-test-scenario test-scenario-class :name "TestScenario1" :parent parent))
(is (= (length (clest:list-children parent)) (+ no 2)))
;; Adding sub-test suites (should error)
(signals error
(clest:make-test-scenario test-scenario-class :name "TestScenario1" :parent ts1))
(signals error
(clest:make-test-suite test-scenario-class :name "TestScenario2a" :parent ts2))
ts1))
(defun test-test-case-protocol (test-case-class &key parent)
(let ((tc1 (clest:make-test-case test-case-class :parent parent :name "TestCase1"))
(tc2 (clest:make-test-case test-case-class :parent parent :name "TestCase2")))
(declare (ignore tc2))
(is (= (length (clest:list-children parent)) 2))
tc1))
| 9,639 | Common Lisp | .lisp | 150 | 56.126667 | 101 | 0.674227 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 294becf7184373a339fee5f5aefd6283817108ab990f7df1e4ca48d67015674e | 35,068 | [
-1
] |
35,069 | protocol.lisp | TurtleWarePL_clest/core/protocol.lisp | ;;;; protocol.lisp
(in-package #:clest)
;;; Classes
(define-protocol-class project) ; root for all project suites
(define-protocol-class test-suite) ; test suites - intermediate tree nodes
(define-protocol-class test-scenario) ; usage pattern (tree leafs)
(define-protocol-class test-case) ; cases of usage pattern
#|
(define-protocol-class testing-plan) ; testing plan
(define-protocol-class build) ; currently tested build (release)
(define-protocol-class requirement) ; software specification
(define-protocol-class documentation) ; software documentation
|#
;;; Conditions
(define-condition clest-error (error) ())
(define-condition child-already-exists (clest-error) ())
(define-condition child-doesnt-exist (clest-error) ())
(define-condition invalid-designator (clest-error) ())
(define-condition invalid-parent-type (clest-error) ())
;;; Synopsis protocol
(defgeneric name (object)
(:documentation "Returns unique object string identifier."))
(defgeneric description (object)
(:documentation "Returns opaque object being object's description."))
;;; Test tree protocol
(defgeneric list-children (parent))
(defgeneric save-child (parent object))
(defgeneric load-child (parent object))
(defgeneric delete-child (parent object))
;;; Project protocol
(defgeneric make-project (type &key name parent &allow-other-keys))
(defgeneric extensions (project))
;;; Test suite protocol
(defgeneric make-test-suite (type &key name parent &allow-other-keys))
;;; Test scenario protocol
(defgeneric make-test-scenario (type &key name parent &allow-other-keys))
;;; Test case protocol
(defgeneric make-test-case (type &key name parent &allow-other-keys))
| 1,689 | Common Lisp | .lisp | 38 | 42.973684 | 77 | 0.76909 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | f7943297868ebd5a71297854334e1e2bb2b581c424263b61ea935987a59c0211 | 35,069 | [
-1
] |
35,070 | basic-implementation.lisp | TurtleWarePL_clest/core/basic-implementation.lisp | (in-package #:clest)
(defmacro check-designator (name)
`(unless (typep ,name 'string)
(error 'clest:invalid-designator)))
(defmacro check-parent (parent type)
`(unless (typep ,parent ',type)
(error 'clest:invalid-parent-type)))
(defclass basic-project (project
test-suite-parent-mixin)
((test-plans :reader list-test-plans)))
(defmethod make-project ((type (eql 'basic-project)) &key name parent)
(check-designator name)
(let ((object (make-instance type :name name)))
(save-child parent object)))
(defclass basic-test-suite (test-suite
test-suite-parent-mixin
test-scenario-parent-mixin)
())
(defmethod make-test-suite ((type (eql 'basic-test-suite)) &key name parent)
(check-designator name)
(check-parent parent test-suite-parent-mixin)
(let ((object (make-instance type :name name)))
(save-child parent object)))
(defmethod save-child :before ((parent t) (object basic-test-suite))
(unless (typep parent 'test-suite-parent-mixin)
(error 'clest:invalid-parent-type :parent parent :object object)))
(defclass basic-test-scenario (test-scenario
test-case-parent-mixin)
())
(defmethod make-test-scenario ((type (eql 'basic-test-scenario)) &key name parent)
(check-designator name)
(check-parent parent test-scenario-parent-mixin)
(let ((object (make-instance type :name name)))
(save-child parent object)))
(defmethod save-child :before ((parent t) (object basic-test-scenario))
(unless (typep parent 'test-scenario-parent-mixin)
(error 'clest:invalid-parent-type :parent parent :object object)))
(defclass basic-test-case (test-case
tree-leaf-mixin)
())
(defmethod make-test-case ((type (eql 'basic-test-case)) &key name parent)
(check-designator name)
(check-parent parent test-case-parent-mixin)
(let ((object (make-instance type :name name)))
(save-child parent object)))
(defmethod save-child :before ((parent t) (object basic-test-case))
(unless (typep parent 'test-case-parent-mixin)
(error 'clest:invalid-parent-type :parent parent :object object)))
| 2,188 | Common Lisp | .lisp | 48 | 39.791667 | 82 | 0.687823 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 5605703748aa285ac6a7b46d544dbb7580a593fd42223ba9028f98c68758ddb1 | 35,070 | [
-1
] |
35,071 | world.lisp | TurtleWarePL_clest/core/world.lisp | (in-package #:clest)
;;; Singleton project list (parent is nil)
(defvar *projects* (make-hash-table :test #'equal))
(defmethod list-children ((parent null))
(hash-table-values *projects*))
(defmethod load-child ((parent null) (name string))
(or (gethash name *projects*)
(error 'clest:child-doesnt-exist :parent parent :name name)))
(defmethod delete-child ((parent null) (name string))
(or (remhash name *projects*)
(error 'clest:child-doesnt-exist :parent parent :name name)))
(defmethod save-child ((parent null) (object project))
(if-let ((child #1=(gethash (name object) *projects*)))
(error 'clest:child-already-exists :parent parent :child child :object object)
(setf #1# object)))
;;; Parent mixins
(defclass project-parent-mixin (tree-parent-mixin) ())
(defclass test-suite-parent-mixin (tree-parent-mixin) ())
(defclass test-scenario-parent-mixin (tree-parent-mixin) ())
(defclass test-case-parent-mixin (tree-parent-mixin) ())
| 987 | Common Lisp | .lisp | 20 | 46.55 | 82 | 0.710115 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | 6d1432a6fc00c374b5aa6584fecaafb21756de146ce9d35255c24fc7e9fd7009 | 35,071 | [
-1
] |
35,072 | clest.asd | TurtleWarePL_clest/clest.asd | ;;;; clest.asd
(asdf:defsystem #:clest
:description "CL tests go east."
:author "Daniel Kochmański"
:license "MIT"
:version "0.0.1"
:depends-on (#:1am #:alexandria #:mcclim)
:serial t
:components ((:file "package")
(:file "clest") ; utilities and mixins
(:module "core"
:description "Core protocol and basic implementation."
:components ((:file "protocol")
(:file "world") ; default root node
(:file "basic-implementation")))
(:module "tests"
:description "Unit tests of the protocol."
:components ((:file "unit-tests")))
(:module "interface"
:description "CLIM interface."
:components ((:file "application-frame")
(:file "tree-pane")
(:file "tree-gadget")))))
| 1,039 | Common Lisp | .asd | 23 | 28.217391 | 78 | 0.454187 | TurtleWarePL/clest | 0 | 0 | 1 | AGPL-3.0 | 9/19/2024, 11:43:28 AM (Europe/Amsterdam) | a9041377c6a52fc664ea17795b88f884f55ca1add29f78a1ff8f2a946bef75e4 | 35,072 | [
-1
] |
35,097 | normaligi.lisp | fisxoj_disirigi/src/normaligi.lisp | (defpackage :disirigi/normaligi
(:use #:cl
#:alexandria)
(:export #:akzentebla-p
#:akzentita-p
#:helplitero-p
#:akzentigu
#:malakzentigu
#:normaligu
#:malnormaligu
))
(in-package #:disirigi/normaligi)
(defconstant +cirkumfleksaj-literoj+
'((#\c . #\ĉ)
(#\s . #\ŝ)
(#\g . #\ĝ)
(#\j . #\ĵ)
(#\h . #\ĥ)
(#\u . #\ŭ))
"Literoj kiuj akceptas cirkumflekson.")
(defconstant +helpliteroj+
'(#\h #\x #\j)
"Literoj kiuj signifas ke la malproksima litero estus akzentita.")
(defun akzentebla-p (c)
(declare (type character c))
(member c +cirkumfleksaj-literoj+ :test #'char-equal :key #'car))
(defun akzentita-p (c)
(declare (type character c))
(member c +cirkumfleksaj-literoj+ :test #'char-equal :key #'cdr))
(defun helplitero-p (c)
(declare (type character c))
(member c +helpliteroj+ :test #'char-equal))
(defun akzentigu (c &optional preserve-case)
(declare (type character c))
(if-let ((akzentito (or (cdr (assoc c +cirkumfleksaj-literoj+ :test #'char-equal)) c)))
(if preserve-case
(if (upper-case-p c)
(char-upcase akzentito)
(char-downcase akzentito))
akzentito)))
(defun malakzentigu (c &optional preserve-case)
(if-let ((akzentito (or (car (rassoc c +cirkumfleksaj-literoj+ :test #'char-equal)) c)))
(if preserve-case
(if (upper-case-p c)
(char-upcase akzentito)
(char-downcase akzentito))
akzentito)))
(defun normaligu (string)
(with-output-to-string (s)
(loop with akzenteblo
for c across string
do (progn (if (and (null akzenteblo) (akzentebla-p c))
(setf akzenteblo c)
(if akzenteblo
(progn (if (helplitero-p c)
(princ (akzentigu akzenteblo t) s)
(progn (princ akzenteblo s)
(princ c s)))
(setf akzenteblo nil))
(princ c s)))))))
(defun malnormaligu (string &optional (helplitero #\x))
(with-output-to-string (s)
(loop for c across string
if (akzentita-p c)
do (princ (malakzentigu c t) s)
and do (princ helplitero s)
else
do (princ c s))))
| 2,434 | Common Lisp | .lisp | 68 | 26.117647 | 90 | 0.548085 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | 2d80a5121cc0273c0310fc45c4505caf25de553ee96476a3d25d3795f12c051a | 35,097 | [
-1
] |
35,098 | disirigi.lisp | fisxoj_disirigi/src/disirigi.lisp | (defpackage :disirigi
(:use #:cl
#:alexandria))
(in-package #:disirigi)
(defmacro a≈≠ (&rest aroj)
`(append ,@aroj))
(defun radikaligu (vorton)
)
(defparameter +postfiksoj+
'("a" "e" "i" "o"
;; Verbs
"as" "is" "os" "us" "u"
;; Participles
"inta" "onta" "anta"
"ita" "ota" "ata"
"intaj" "ontaj" "antaj"
"itaj" "otaj" "ataj"
;; Gerund-likes
"into" "onto" "anto"
"ito" "oto" "ato"
"intoj" "ontoj" "antoj"
"itoj" "otoj" "atoj"
))
| 504 | Common Lisp | .lisp | 23 | 17.521739 | 27 | 0.543524 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | 09fe5f2cbd463bd3cc16de838d414ed9db7ba29c9d9b0eedc3ce5bf6522a0e55 | 35,098 | [
-1
] |
35,099 | normaligi.lisp | fisxoj_disirigi/t/normaligi.lisp | (defpackage :t/disirigi/normaligi
(:use #:cl #:prove #:alexandria #:disirigi/normaligi))
(in-package #:t/disirigi/normaligi)
(defvar +cxiu-litero+ '(#\a #\b #\c #\ĉ #\d #\e #\f #\g #\ĝ #\h #\ĥ #\i #\j #\ĵ #\k #\l #\m #\n #\o #\p #\q #\r #\s #\ŝ #\t #\u #\ŭ #\v #\w #\x #\y #\z))
(defvar +akzentebla+ '(#\c #\j #\g #\s #\h #\u))
(defvar +akzentitaj+ '(#\ĉ #\ĝ #\ĥ #\ĵ #\ŝ #\ŭ))
(defvar +helpliteroj+ '(#\h #\x #\j))
(plan 7)
(subtest "akzentebla-p"
(ok (every #'akzentebla-p +akzentebla+)
"All accentable letters are recognized.")
(ok (notany #'akzentebla-p (set-difference +akzentebla+ +cxiu-litero+))
"No non-accentable letter is incorrecly marked accentable."))
(subtest "akzentita-p"
(ok (every #'akzentita-p +akzentitaj+)
"Every accented character is recognized as such.")
(ok (notany #'akzentita-p (set-difference +akzentitaj+ +cxiu-litero+))
"No unaccented character is misidentified."))
(subtest "helplitero-p"
(ok (every #'helplitero-p +helpliteroj+)
"All help-letters are identified.")
(ok (notany #'helplitero-p (set-difference +helpliteroj+ +cxiu-litero+))
"No other letters are mistaken for a help-letter."))
(subtest "akzentigu"
(ok (every (lambda (e) (char= (cdr e) (akzentigu (car e)))) disrigi/normaligi::+cirkumfleksaj-literoj+)
"All accentable letters are turned into their correct counterpart.")
(let ((case-fns (alexandria:circular-list #'char-upcase #'char-downcase)))
(ok (every (lambda (e) (let ((case-fn (pop case-fns))) (char= (funcall case-fn (cdr e)) (akzentigu (funcall case-fn (car e)) t)))) disrigi/normaligi::+cirkumfleksaj-literoj+)
"All accentable letters are turned into their correct counterpart, preserving case."))
(ok (every (lambda (c) (char= c (akzentigu c))) (set-difference +akzentebla+ +cxiu-litero+))
"All non-accentable letters are returned as-is."))
(subtest "akzentigu"
(ok (every (lambda (e) (char= (car e) (malakzentigu (cdr e)))) disrigi/normaligi::+cirkumfleksaj-literoj+)
"All accented letters are turned into their correct counterpart.")
(let ((case-fns (alexandria:circular-list #'char-upcase #'char-downcase)))
(ok (every (lambda (e) (let ((case-fn (pop case-fns))) (char= (funcall case-fn (car e)) (malakzentigu (funcall case-fn (cdr e)) t)))) disrigi/normaligi::+cirkumfleksaj-literoj+)
"All accented letters are turned into their correct counterpart, preserving case."))
(ok (every (lambda (c) (char= c (malakzentigu c))) (set-difference +akzentebla+ +cxiu-litero+))
"All non-accentable letters are returned as-is."))
(subtest "normaligu"
(is (normaligu "La cxevalo mangxas la novajxon en Hxinio.") "La ĉevalo manĝas la novaĵon en Ĥinio."))
(subtest "malnormaliu"
(is (malnormaligu "La ĉevalo manĝas la novaĵon en Ĥinio.") "La cxevalo mangxas la novajxon en Hxinio."))
(finalize)
| 2,891 | Common Lisp | .lisp | 44 | 61.227273 | 181 | 0.674501 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | 0a540821222287e9abeaa4a0afad21c6df59aee149797af5f093e8bf738ef977 | 35,099 | [
-1
] |
35,100 | disirigi.asd | fisxoj_disirigi/disirigi.asd | (asdf:defsystem "disirigi"
:author "Matt Novenstern <[email protected]>"
:license "LLGPLv3+"
:pathname #P"src/"
:depends-on ("alexandria")
:components ((:file "normaligi")
(:file "disirigi"))
:in-order-to ((test-op (test-op disirigi-test))))
| 268 | Common Lisp | .asd | 8 | 29.125 | 51 | 0.646154 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | 5ace2db668f3b5b9f1ef057ed672cb55ed3bb833019e5b62a3b57afbaa0ea69c | 35,100 | [
-1
] |
35,101 | disirigi-test.asd | fisxoj_disirigi/disirigi-test.asd | (defsystem "disirigi-test"
:author "Matt Novenstern"
:pathname #P"t/"
:depends-on ("disirigi"
"prove")
:components ((:test-file "normaligi"))
:defsystem-depends-on ("prove-asdf")
:perform (test-op (op c) (symbol-call :prove-asdf '#:run-test-system c)))
| 280 | Common Lisp | .asd | 8 | 30.625 | 75 | 0.647059 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | 27a1993b53385f4fb54833e8c68cd5f58f5bbacf7529c3616c034c04960e2b72 | 35,101 | [
-1
] |
35,103 | .travis.yml | fisxoj_disirigi/.travis.yml | language: common-lisp
sudo: false
env:
global:
- PATH=$HOME/.roswell/bin:$PATH
- ROSWELL_INSTALL_DIR=$HOME/.roswell
- COVERAGE_EXCLUDE=t
matrix:
- LISP=sbcl-bin COVERALLS=true
- LISP=ccl-bin
install:
# Install Roswell
- curl -L https://raw.githubusercontent.com/snmsts/roswell/release/scripts/install-for-ci.sh | sh
- ros install prove
# Coveralls support
- git clone https://github.com/fukamachi/cl-coveralls ~/lisp/cl-coveralls
cache:
directories:
- $HOME/.roswell
- $HOME/.config/common-lisp
before_script:
- ros --version
- ros config
script:
- run-prove disirigi-test.asd
| 632 | Common Lisp | .l | 25 | 22.08 | 99 | 0.72093 | fisxoj/disirigi | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:36 AM (Europe/Amsterdam) | d7c50547ceb2abc0926152feff08c3544002ebe5f54303aea082117ffc22ae31 | 35,103 | [
-1
] |
35,121 | package.lisp | azimut_cl-gme/package.lisp | (uiop:define-package #:cl-gme
(:use #:cl #:cffi)
(:export #:with-file
#:with-track
#:track-count
#:track-info
#:voice-count
#:voice-names))
| 201 | Common Lisp | .lisp | 8 | 16.5 | 29 | 0.481865 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 3914885956684b9c018d43606a3614014429a16d894c70e91c1653ec8d0c97e7 | 35,121 | [
-1
] |
35,122 | cl-gme-cffi.lisp | azimut_cl-gme/cl-gme-cffi.lisp | ;;; This file was automatically generated by SWIG (http://www.swig.org).
;;; Version 3.0.12
;;;
;;; Do not make changes to this file unless you know what you are doing--modify
;;; the SWIG interface file instead.
(in-package #:cl-gme)
(define-foreign-library gme
(:unix (:or "/usr/lib64/libgme.so.0.6.2"
"/usr/lib64/libgme.so.0.6.1"
"/usr/lib64/libgme.so"))
(t (:default "/usr/lib/libgme.so")))
(use-foreign-library gme)
(defmacro define-constant (name value &optional doc)
`(defconstant ,name (if (boundp ',name) (symbol-value ',name) ,value)
,@(when doc (list doc))))
;;;SWIG wrapper code starts here
(cl:defmacro defanonenum (cl:&body enums)
"Converts anonymous enums to defconstants."
`(cl:progn ,@(cl:loop for value in enums
for index = 0 then (cl:1+ index)
when (cl:listp value) do (cl:setf index (cl:second value)
value (cl:first value))
collect `(define-constant ,value ,index))))
(cl:eval-when (:compile-toplevel :load-toplevel)
(cl:unless (cl:fboundp 'swig-lispify)
(cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
(cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
(cl:cond
((cl:null lst)
rest)
((cl:upper-case-p c)
(helper (cl:cdr lst) 'upper
(cl:case last
((lower digit) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:lower-case-p c)
(helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
((cl:digit-char-p c)
(helper (cl:cdr lst) 'digit
(cl:case last
((upper lower) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:char-equal c #\_)
(helper (cl:cdr lst) '_ (cl:cons #\- rest)))
(cl:t
(cl:error "Invalid character: ~A" c)))))
(cl:let ((fix (cl:case flag
((constant enumvalue) "+")
(variable "*")
(cl:t ""))))
(cl:intern
(cl:concatenate
'cl:string
fix
(cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
fix)
package))))))
;;;SWIG wrapper code ends here
(define-constant GME_VERSION #x000602)
(cl:export 'GME_VERSION)
(cffi:defcfun ("gme_open_file" gme_open_file) :string
(path :pointer)
(out :pointer)
(sample_rate :int))
(cl:export 'gme_open_file)
(cffi:defcfun ("gme_track_count" gme_track_count) :int
(arg0 :pointer))
(cl:export 'gme_track_count)
(cffi:defcfun ("gme_start_track" gme_start_track) :string
(arg0 :pointer)
(index :int))
(cl:export 'gme_start_track)
(cffi:defcfun ("gme_play" gme_play) :string
(arg0 :pointer)
(count :int)
(out :pointer))
(cl:export 'gme_play)
(cffi:defcfun ("gme_delete" gme_delete) :void
(arg0 :pointer))
(cl:export 'gme_delete)
(cffi:defcfun ("gme_set_fade" gme_set_fade) :void
(arg0 :pointer)
(start_msec :int))
(cl:export 'gme_set_fade)
(cffi:defcfun ("gme_track_ended" gme_track_ended) :int
(arg0 :pointer))
(cl:export 'gme_track_ended)
(cffi:defcfun ("gme_tell" gme_tell) :int
(arg0 :pointer))
(cl:export 'gme_tell)
(cffi:defcfun ("gme_tell_samples" gme_tell_samples) :int
(arg0 :pointer))
(cl:export 'gme_tell_samples)
(cffi:defcfun ("gme_seek" gme_seek) :string
(arg0 :pointer)
(msec :int))
(cl:export 'gme_seek)
(cffi:defcfun ("gme_seek_samples" gme_seek_samples) :string
(arg0 :pointer)
(n :int))
(cl:export 'gme_seek_samples)
(defanonenum
(gme_info_only #.-1))
(cl:export 'gme_info_only)
(cffi:defcfun ("gme_warning" gme_warning) :string
(arg0 :pointer))
(cl:export 'gme_warning)
(cffi:defcfun ("gme_load_m3u" gme_load_m3u) :string
(arg0 :pointer)
(path :pointer))
(cl:export 'gme_load_m3u)
(cffi:defcfun ("gme_clear_playlist" gme_clear_playlist) :void
(arg0 :pointer))
(cl:export 'gme_clear_playlist)
(cffi:defcfun ("gme_track_info" gme_track_info) :string
(arg0 :pointer)
(out :pointer)
(track :int))
(cl:export 'gme_track_info)
(cffi:defcfun ("gme_free_info" gme_free_info) :void
(arg0 :pointer))
(cl:export 'gme_free_info)
(cffi:defcstruct gme_info_t
(length :int)
(intro_length :int)
(loop_length :int)
(play_length :int)
(i4 :int)
(i5 :int)
(i6 :int)
(i7 :int)
(i8 :int)
(i9 :int)
(i10 :int)
(i11 :int)
(i12 :int)
(i13 :int)
(i14 :int)
(i15 :int)
(system :string)
(game :string)
(song :string)
(author :string)
(copyright :string)
(comment :string)
(dumper :string)
(s7 :string)
(s8 :string)
(s9 :string)
(s10 :string)
(s11 :string)
(s12 :string)
(s13 :string)
(s14 :string)
(s15 :string))
(cl:export 'gme_info_t)
(cl:export 'length)
(cl:export 'intro_length)
(cl:export 'loop_length)
(cl:export 'play_length)
(cl:export 'i4)
(cl:export 'i5)
(cl:export 'i6)
(cl:export 'i7)
(cl:export 'i8)
(cl:export 'i9)
(cl:export 'i10)
(cl:export 'i11)
(cl:export 'i12)
(cl:export 'i13)
(cl:export 'i14)
(cl:export 'i15)
(cl:export 'system)
(cl:export 'game)
(cl:export 'song)
(cl:export 'author)
(cl:export 'copyright)
(cl:export 'comment)
(cl:export 'dumper)
(cl:export 's7)
(cl:export 's8)
(cl:export 's9)
(cl:export 's10)
(cl:export 's11)
(cl:export 's12)
(cl:export 's13)
(cl:export 's14)
(cl:export 's15)
(cffi:defcfun ("gme_set_stereo_depth" gme_set_stereo_depth) :void
(arg0 :pointer)
(depth :double))
(cl:export 'gme_set_stereo_depth)
(cffi:defcfun ("gme_ignore_silence" gme_ignore_silence) :void
(arg0 :pointer)
(ignore :int))
(cl:export 'gme_ignore_silence)
(cffi:defcfun ("gme_set_tempo" gme_set_tempo) :void
(arg0 :pointer)
(tempo :double))
(cl:export 'gme_set_tempo)
(cffi:defcfun ("gme_voice_count" gme_voice_count) :int
(arg0 :pointer))
(cl:export 'gme_voice_count)
(cffi:defcfun ("gme_voice_name" gme_voice_name) :string
(arg0 :pointer)
(i :int))
(cl:export 'gme_voice_name)
(cffi:defcfun ("gme_mute_voice" gme_mute_voice) :void
(arg0 :pointer)
(index :int)
(mute :int))
(cl:export 'gme_mute_voice)
(cffi:defcfun ("gme_mute_voices" gme_mute_voices) :void
(arg0 :pointer)
(muting_mask :int))
(cl:export 'gme_mute_voices)
(cffi:defcstruct gme_equalizer_t
(treble :double)
(bass :double)
(d2 :double)
(d3 :double)
(d4 :double)
(d5 :double)
(d6 :double)
(d7 :double)
(d8 :double)
(d9 :double))
(cl:export 'gme_equalizer_t)
(cl:export 'treble)
(cl:export 'bass)
(cl:export 'd2)
(cl:export 'd3)
(cl:export 'd4)
(cl:export 'd5)
(cl:export 'd6)
(cl:export 'd7)
(cl:export 'd8)
(cl:export 'd9)
(cffi:defcfun ("gme_equalizer" gme_equalizer) :void
(arg0 :pointer)
(out :pointer))
(cl:export 'gme_equalizer)
(cffi:defcfun ("gme_set_equalizer" gme_set_equalizer) :void
(arg0 :pointer)
(eq :pointer))
(cl:export 'gme_set_equalizer)
(cffi:defcfun ("gme_enable_accuracy" gme_enable_accuracy) :void
(arg0 :pointer)
(enabled :int))
(cl:export 'gme_enable_accuracy)
(cffi:defcvar ("gme_ay_type" gme_ay_type)
:pointer)
(cl:export 'gme_ay_type)
(cffi:defcvar ("gme_gbs_type" gme_gbs_type)
:pointer)
(cl:export 'gme_gbs_type)
(cffi:defcvar ("gme_gym_type" gme_gym_type)
:pointer)
(cl:export 'gme_gym_type)
(cffi:defcvar ("gme_hes_type" gme_hes_type)
:pointer)
(cl:export 'gme_hes_type)
(cffi:defcvar ("gme_kss_type" gme_kss_type)
:pointer)
(cl:export 'gme_kss_type)
(cffi:defcvar ("gme_nsf_type" gme_nsf_type)
:pointer)
(cl:export 'gme_nsf_type)
(cffi:defcvar ("gme_nsfe_type" gme_nsfe_type)
:pointer)
(cl:export 'gme_nsfe_type)
(cffi:defcvar ("gme_sap_type" gme_sap_type)
:pointer)
(cl:export 'gme_sap_type)
(cffi:defcvar ("gme_spc_type" gme_spc_type)
:pointer)
(cl:export 'gme_spc_type)
(cffi:defcvar ("gme_vgm_type" gme_vgm_type)
:pointer)
(cl:export 'gme_vgm_type)
(cffi:defcvar ("gme_vgz_type" gme_vgz_type)
:pointer)
(cl:export 'gme_vgz_type)
(cffi:defcfun ("gme_type" gme_type) :pointer
(arg0 :pointer))
(cl:export 'gme_type)
(cffi:defcfun ("gme_type_list" gme_type_list) :pointer)
(cl:export 'gme_type_list)
(cffi:defcfun ("gme_type_system" gme_type_system) :string
(arg0 :pointer))
(cl:export 'gme_type_system)
(cffi:defcfun ("gme_type_multitrack" gme_type_multitrack) :int
(arg0 :pointer))
(cl:export 'gme_type_multitrack)
(cffi:defcfun ("gme_multi_channel" gme_multi_channel) :int
(arg0 :pointer))
(cl:export 'gme_multi_channel)
(cffi:defcvar ("gme_wrong_file_type" gme_wrong_file_type)
:string)
(cl:export 'gme_wrong_file_type)
(cffi:defcfun ("gme_open_data" gme_open_data) :string
(data :pointer)
(size :long)
(out :pointer)
(sample_rate :int))
(cl:export 'gme_open_data)
(cffi:defcfun ("gme_identify_header" gme_identify_header) :string
(header :pointer))
(cl:export 'gme_identify_header)
(cffi:defcfun ("gme_identify_extension" gme_identify_extension) :pointer
(path_or_extension :pointer))
(cl:export 'gme_identify_extension)
(cffi:defcfun ("gme_type_extension" gme_type_extension) :string
(music_type :pointer))
(cl:export 'gme_type_extension)
(cffi:defcfun ("gme_identify_file" gme_identify_file) :string
(path :pointer)
(type_out :pointer))
(cl:export 'gme_identify_file)
(cffi:defcfun ("gme_new_emu" gme_new_emu) :pointer
(arg0 :pointer)
(sample_rate :int))
(cl:export 'gme_new_emu)
(cffi:defcfun ("gme_new_emu_multi_channel" gme_new_emu_multi_channel) :pointer
(arg0 :pointer)
(sample_rate :int))
(cl:export 'gme_new_emu_multi_channel)
(cffi:defcfun ("gme_load_file" gme_load_file) :string
(arg0 :pointer)
(path :pointer))
(cl:export 'gme_load_file)
(cffi:defcfun ("gme_load_data" gme_load_data) :string
(arg0 :pointer)
(data :pointer)
(size :long))
(cl:export 'gme_load_data)
(cffi:defcfun ("gme_load_custom" gme_load_custom) :string
(arg0 :pointer)
(arg1 :pointer)
(file_size :long)
(your_data :pointer))
(cl:export 'gme_load_custom)
(cffi:defcfun ("gme_load_m3u_data" gme_load_m3u_data) :string
(arg0 :pointer)
(data :pointer)
(size :long))
(cl:export 'gme_load_m3u_data)
(cffi:defcfun ("gme_set_user_data" gme_set_user_data) :void
(arg0 :pointer)
(new_user_data :pointer))
(cl:export 'gme_set_user_data)
(cffi:defcfun ("gme_user_data" gme_user_data) :pointer
(arg0 :pointer))
(cl:export 'gme_user_data)
(cffi:defcfun ("gme_set_user_cleanup" gme_set_user_cleanup) :void
(arg0 :pointer)
(func :pointer))
(cl:export 'gme_set_user_cleanup)
| 10,827 | Common Lisp | .lisp | 358 | 25.756983 | 86 | 0.64643 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 8a0cc2806ff493a192d2eedad868b155dcc0496e4cab9734bad40db9a6bc11cc | 35,122 | [
-1
] |
35,123 | cl-gme.lisp | azimut_cl-gme/cl-gme.lisp | (in-package #:cl-gme)
(defun indices (max)
(loop :for i :from 0 :to (1- max)
:collect i))
(defun comp-voices (voices nvoices)
(let ((voices (remove-duplicates voices :test #'=)))
(loop
:for i :in (indices nvoices)
:when (not (position i voices))
:collect i)))
(defmacro with-open ((var file &key (rate 44100)) &body body)
"opens FILE and returns a file descriptor into VAR
closes the descriptor after the block ends"
`(cffi:with-foreign-string (cffi-filename ,file)
(cffi:with-foreign-object (,var :pointer)
(gme_open_file cffi-filename ,var ,rate)
(unwind-protect (progn ,@body)
(gme_delete (mem-ref ,var :pointer))))))
(defmacro with-track ((var file track-number
&key
(rate 44100)
(voices '()))
&body body)
"opens FILE in TRACK-NUMBER and returns file descriptor into VAR
closes the file descriptor after the block ends"
`(with-open (,var ,file :rate ,rate)
;; ensure we do try to listen more tracks than available ones
(let ((ntracks (gme_track_count (mem-ref ,var :pointer))))
(gme_start_track (mem-ref ,var :pointer) (alexandria:clamp ,track-number 0 (1- ntracks))))
;; mute voices when provided
(when ,voices
(let ((nvoices (gme_voice_count (mem-ref ,var :pointer))))
(mapcar (lambda (v) (gme_mute_voice (cffi:mem-ref ,var :pointer) v 1))
(comp-voices ,voices nvoices))))
,@body))
;;--------------------------------------------------
(defun track-count (file)
"returns the number of tracks on FILE"
(declare (type string file))
(with-open (ggme file)
(gme_track_count (mem-ref ggme :pointer))))
(defun voice-count (file)
"returns the number of voices on FILE"
(declare (type string file))
(with-open (ggme file)
(gme_voice_count (mem-ref ggme :pointer))))
(defun voice-names (file)
"returns a list of cons with the voice number and name"
(with-open (ggme file)
(let* ((p (mem-ref ggme :pointer))
(nvoices (gme_voice_count p)))
(loop :for voice :from 0 :upto (1- nvoices) :collect
(cons voice (gme_voice_name p voice))))))
(defun track-info (file &optional (track-number 0))
(declare (type string file))
(with-open (ggme file)
(with-foreign-object (info :pointer)
(gme_track_info (mem-ref ggme :pointer) info track-number)
(with-foreign-slots ((length intro_length loop_length play_length game song)
info
(:struct gme_info_t))
(format t "Length: ~a ~%ILength: ~a ~%LLength: ~a ~%PLength: ~a"
length loop_length intro_length play_length)
(format t "~%Game: ~a Song: ~a"
game song))
(gme_free_info (mem-ref info :pointer)))))
| 2,867 | Common Lisp | .lisp | 66 | 35.818182 | 97 | 0.601719 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 5a6d4e49670938e65862e08f3dd6b0d3e33f8fa68d620b639a1723af8f79c94a | 35,123 | [
-1
] |
35,124 | test.lisp | azimut_cl-gme/t/test.lisp | (in-package #:cl-gme)
;; Below are some example calls to the library, notice that are on
;; a nsf (nintendo sound font) file but it can be any other of the
;; ones supported by gme
;;------------------------------------------------
(require 'sdl2-mixer)
(defparameter *nsf-file-path* "/home/sendai/testfield/alien.nsf")
;; trying with "small" chunks makes the playing reaaaaly slow
;; sometimes it works ok-ish, but really bad in comparison to big buffers
;; multiples of 44100
;; still sucks...I think I just need to have the read/write part happen at a lower level
(defun gmeplay (&optional (track-number 0)
(buff-size 500) (loops 1)
(mute-voices '()))
(with-track (ggme *nsf-file-path* track-number)
(with-foreign-objects ((array :short buff-size))
(when mute-voices
(loop :for voice :in mute-voices
:do (gme_mute_voice (mem-ref ggme :pointer) voice 1)))
(sdl2-mixer:open-audio 44100 :s16sys 2 buff-size)
(sdl2-mixer:allocate-channels 1)
;; CHUNKS!!!
(plus-c:c-with ((mychunk sdl2-ffi:mix-chunk))
(setf (mychunk :volume) 30
(mychunk :allocated) 1
(mychunk :abuf) array
(mychunk :alen) buff-size)
(loop :with i = 0
:do
(if (equal 0 (sdl2-mixer:playing 0))
(progn
(incf i)
(when (> i loops) (return))
(gme_play (mem-ref ggme :pointer) buff-size array)
(sdl2-mixer:play-channel 0 mychunk 0))
;; needs to be smaaaall (.0001),
;; and even so the glitch is audible
(sleep .01)))
(sdl2-mixer:close-audio))))
;; https://www.libsdl.org/projects/SDL_mixer/docs/SDL_mixer.html#SEC11
;;(sdl2-mixer:open-audio 44100 :s16sys 2 4096) ;; 4096?
;;(sdl2-mixer:allocate-channels 2)
;;(sdl2-mixer:play-channel 0 (are) 0)
;;(sdl2-mixer:open-audio 44100 :s16sys 2 500)
;; allocate chunk
;;(c-with ((mychunk sdl2-ffi:mix-chunk)) (mychunk :allocated))
)
;; Trying to write to a .txt as an attempt to make it available to incudine
;; NOTE: (* .00001 ) if you want to play it elsewhere
(defun gmerecord (&optional (track-number 0) (buff-size 500) (loops 1)
(mute-voices '()))
(with-open (ggme *nsf-file-path*)
(with-foreign-object (array :short buff-size)
(gme_start_track (mem-ref ggme :pointer) track-number)
(when mute-voices
(loop :for voice :in mute-voices
:do (gme_mute_voice (mem-ref ggme :pointer) voice 1)))
;; CHUNKS!!!
(with-open-file
(f "/home/sendai/out.txt"
:direction :output
:if-exists :supersede)
(gme_play (mem-ref ggme :pointer) buff-size array)
(dotimes (i buff-size)
(write-line (format nil "~F" (mem-aref array :short i))
f))))))
;; --------------------------------------------------
(defvar *arr* nil)
;; Used to put the file into a vector, useful for cl-out123
;; NOTE: (* .00001 ) if you want to play it elsewhere
(defun gmevector (&optional (track-number 0)
(buff-size 500) (loops 1)
(mute-voices '()))
(setf *arr* (make-array buff-size :element-type 'single-float))
(with-track (ggme *nsf-file-path* track-number)
(with-foreign-object (array :short buff-size)
(when mute-voices
(loop :for voice :in mute-voices
:do (gme_mute_voice (mem-ref ggme :pointer) voice 1)))
;; CHUNKS!!!
(gme_play (mem-ref ggme :pointer) buff-size array)
(dotimes (i buff-size)
(setf (aref *arr* i)
(float (mem-aref array :short i)))))))
| 3,716 | Common Lisp | .lisp | 84 | 36.119048 | 88 | 0.584874 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 855d8971866b835895bfa4ff5c1caf604ca5214563fd9d0aea55b32b960c5fbe | 35,124 | [
-1
] |
35,125 | gmeincudine.lisp | azimut_cl-gme/contrib/gmeincudine.lisp | (in-package :cl-gme)
(pushnew (asdf:system-relative-pathname :cl-gme "contrib/")
*foreign-library-directories*
:test #'equal)
;; (cffi:define-foreign-library gme
;; (:unix (:or "gmeincudine.so")))
(cffi:defcfun ("gmefile_to_buffer" gmefile-to-buffer) :void
(buf :pointer)
(gmefile :pointer)
(frames :unsigned-long)
(offset :unsigned-long))
(load-foreign-library '(:default "gmeincudine"))
| 421 | Common Lisp | .lisp | 12 | 31.583333 | 59 | 0.691358 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 7d2c757c5faac1280e4cc0ade29f1294f940e1f009d26e0f1935e38080179bea | 35,125 | [
-1
] |
35,126 | cl-gme.asd | azimut_cl-gme/cl-gme.asd | (asdf:defsystem #:cl-gme
:description "gme"
:author "azimut <[email protected]>"
:homepage "https://github.com/azimut/cl-gme"
:license "GPL-3.0"
:serial t
:depends-on (#:cffi
#:alexandria)
:components ((:file "package")
(:file "cl-gme-cffi")
(:file "cl-gme")))
(asdf:defsystem #:cl-gme/incudine
:description "gme for incudine"
:author "azimut <[email protected]>"
:homepage "https://github.com/azimut/cl-gme"
:license "GPL-3.0"
:serial t
:depends-on (#:cl-gme)
:components ((:file "contrib/gmeincudine")))
| 624 | Common Lisp | .asd | 19 | 26.789474 | 55 | 0.61755 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 6c6b37b88663a6f6323aa336ef07fda66c7ce38af50bc100b10f2c324a5661e2 | 35,126 | [
-1
] |
35,133 | Makefile | azimut_cl-gme/contrib/Makefile | all:
gcc -lgme -shared -O3 -Wall -D__INCUDINE_USE_64_BIT_SAMPLE__ gmeincudine.c -o gmeincudine.so
clean:
rm -f *.so
| 118 | Common Lisp | .l | 4 | 28 | 93 | 0.710526 | azimut/cl-gme | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:43:52 AM (Europe/Amsterdam) | 9a159582d54d1524defdf817ba3c4f111e94cf566c5f2d6d012deb64f4d82846 | 35,133 | [
-1
] |
35,149 | ab-lisp.asd | bornhoeft_ab-lisp/ab-lisp.asd | (in-package :ASDF)
(defsystem "ab-lisp"
:description "Lisp Library"
:long-description ""
:version "0.2"
:author "Achim Bornhoeft"
:licence "http://creativecommons.org/licenses/by-nc-sa/3.0/"
:maintainer "Achim Bornhoeft"
;; :serial t means that each component is only compiled, when the
;; predecessors are already loaded
:serial t
:components
( (:file "lisp/package") ; package definition
(:file "lisp/boxes") ; define your boxes and other lisp functions
(:file "lisp/envelopes")
(:file "lisp/lists")
(:file "lisp/math")
(:file "lisp/pitchclass")
(:file "lisp/quantisation")
(:file "lisp/random")
(:file "lisp/utilities")
(:file "lisp/menus") ; entries in the popup-menu (right-click)
))
| 741 | Common Lisp | .lisp | 23 | 28.956522 | 78 | 0.690909 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 569e2c87d11f01cfc546e9aea6a8c458b6e2607130cde5d15902bb283d950044 | 35,149 | [
-1
] |
35,150 | ab-lisp.opmows | bornhoeft_ab-lisp/ab-lisp.opmows | ("workspace-view/current"
"lisp/utilities.lisp"
)
("workspace-view/history"
(("lisp/lists.lisp" "lists.lisp") ("lisp/math.lisp" "math.lisp") ("lisp/utilities.lisp" "utilities.lisp") ("lisp/quantisation.lisp" "quantisation.lisp") ("lisp/random.lisp" "random.lisp") ("lisp/spectral.lisp" "spectral.lisp"))
)
("workspace-view/layout-ratios"
(1 (OM-CAPI::MAIN 276 NIL 767) (OM-CAPI::EDITOR-AND-LISTENER-LAYOUT 867 NIL 414))
)
| 428 | Common Lisp | .lisp | 9 | 45.888889 | 228 | 0.721154 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | feb88054c0ee78d739f5d5c04eaf6dcaf8a1145be4ff2105918966acfd99ac8b | 35,150 | [
-1
] |
35,151 | boxes.lisp | bornhoeft_ab-lisp/lisp/boxes.lisp | ;;; Copyright (c) 2009, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; EXAMPLES
;; some box examples with value input-boxes, button input-boxes and menu input-boxes
;; 1 argument name = 'a', default value = 1
(PWGLdef fn1 ((a 1))
"fn1"
()
(list a))
;; 2 arguments 'a' and 'b'
(PWGLdef fn2 ((a 1) (b '(1 2)))
"fn2"
()
(list a b))
;; 3 arguments 'a', 'b' and 'c' grouped as three 1 input-box rows
;; c's default value is a list '(1 2 3)
(PWGLdef fn3 ((a 1) (b '(1 2)) (c '(1 2 3)))
"fn3"
(:groupings '(1 1 1))
(list a b c))
;; 3 required arguments 'a', 'b' and 'c' grouped as three 1 input-box rows
;; and an optional argument of type &rest
(PWGLdef fn4 ((a 1) (b '(1 2)) (c '(1 2 3)) &rest (ds 0))
"fn4"
(:groupings '(1 1 1))
(list a b c ds))
;; this box has three arguments, where the second input is
;; a button subview that changes its title when clicked
;; the third input is a simple menu input-box with three options
(defun change-this (b)
(setf (ccl::box-string b) (if (equal (ccl::box-string b) "OK") "stop" "OK")))
(PWGLdef fn5 ((a 1)
(press () (ccl::mk-button-subview :box-string "OK"
:r 0.7 :g 0.75 :b 0.7
:pwgl-action-function 'change-this))
(c () (ccl::mk-menu-subview :menu-list '("test" "key" "skip"))))
"fn5"
(:w 0.5 :x-proportions '((1 (:fix 0.2)) (1)))
(list a c))
;; a box with 2 menu input-boxes
(PWGLdef fn6 ((a 1) (b () (ccl::mk-menu-subview :menu-list '("yes" "no" "maybe") :value 1))
(c () (ccl::mk-menu-subview :menu-list '("test" "key" "skip") :value 2)))
"fn6"
(:w 0.5 :groupings '(2 1) :x-proportions '((1 (:fix 0.2)) (1)))
(list a b c))
;; a more advanced example with a hierarchical menu input-box
;; both menu-titles and menu-items are cached
(ccl::add-menu-list-keyword :my-hierarchical-menu-titles '("First" "Second" "Third"))
(ccl::add-menu-list-keyword :my-hierarchical-menu-items
'(("a" "b" "c")
("d" "e" "f" "g")
("h" "i" )))
(PWGLdef fn7 ((a () (ccl::mk-hierarchical-menu-subview
:value 0 :value2 2
:menu-titles :my-hierarchical-menu-titles
:menu-list :my-hierarchical-menu-items)))
"fn7"
()
a)
;;; ----------------------------------------------------------
;;; Box for quant function
(system::PWGLdef quantize ((num) (steps))
"rounds value to the nearest multiple of steps. Steps can be a list of values"
()
(quant num steps))
;;; Box for quant-list function
(system::PWGLdef quantize-list ((lis) (steps))
"rounds a list of values to the nearest multiple of steps. Steps can be a list of values"
()
(quant-list lis steps))
(system::PWGLdef same-pc ((keys) (pc))
"Collect and sort all keys of a given pitchclass (or list of pitchclasses) in a row of keynumbers."
()
(same-pitchclass keys pc))
(system::PWGLdef list-intervals ((lis) (interv 0) &optional (start 0))
"Collects all values in a specific interval from a given position in a list"
()
(interval-in-list lis interv))
(system::PWGLdef flat-last ((lis))
"remove additional parens until the last list"
()
(flat-last-list lis))
#|
(system::PWGLdef flat-lasti ((lis))
"remove additional parens until the last list"
()
(let ((l lis))
(loop while (= (length l) 1) do
(setq l (first l))
finally (return l))))
|#
| 4,867 | Common Lisp | .lisp | 111 | 38.648649 | 102 | 0.627538 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | e4f1a5679bf65a954afe116a0bcaaccc7a78ab1039420e96095efefb383fcf44 | 35,151 | [
-1
] |
35,152 | random.lisp | bornhoeft_ab-lisp/lisp/random.lisp | ;;; Copyright (c) 2009-2015, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; Random functions
(defun rand (low high &optional (digits 6))
"Return values chosen at random between low and high including the limits.
If the numbers given are integers the result will be an integer."
(let* ((dig (expt 10 digits))
(hi (* high dig))
(lo (* low dig)))
(if (and (integerp low) (integerp high))
(+ (min low high) (random (abs (+ 1 (- high low)))))
(/ (+ (min lo hi) (random (abs (+ 1 (- hi lo))))) dig))))
;; (loop repeat 10 collect (rand 0 10)) ; => (3 0 3 1 10 0 2 6 4 9)
;; (loop repeat 10 collect (rand 0 1.0)) ; => (0.19683109 0.9814336 0.6428565 0.666238 0.8315703 0.059967414 0.9817517 0.20357414 0.09638849 0.7393965)
;; (loop repeat 10 collect (rand 1 5)) ; => (4 4 3 5 4 5 5 3 1 2)
;; (loop repeat 10 collect (rand -2 3)) ; => (3 3 0 1 3 0 -2 -1 1 0)
;; (loop repeat 10 collect (rand 0.0 1.0)) ; => (0.84254044 0.49642378 0.96591794 0.48625877 0.09820962 0.012784736 0.83146054 0.758958 0.21964629 0.3659834)
;; (loop repeat 10 collect (rand -1 1.0)) ; => (0.43671826 -0.099772654 0.91709256 -0.31474653 0.91441834 -0.75535315 -0.20307846 -0.4239697 0.7960043 0.8241785)
;;; Funktioniert nicht mit Floats
(defun center-random (num)
"Random between positive and negative <num> including the limits.
If the number given is an integer the result will be an integer."
(if (= num 0) 0
(- (random (+ 1 (* 2 num))) num)))
;; (loop repeat 10 collect (center-random 5)) => (-2 0 0 3 2 5 4 -5 1 -2)
;; (loop repeat 5 collect (center-random 5.0)) =>(-3.4431937 0.76110363 1.2877498 2.243022 -0.25518608)
(defun negative-random (num)
"Negative signed numbers between 0 and num."
(if (= num 0) 0
(- (random num) num)))
;; (loop repeat 20 collect (negative-random 10)) => (-4 -1 -5 -1 -9 -4 -1 -6 -1 -8 -4 -10 -4 -6 -1 -6 -6 -10 -8 -6)
(defun sign-random (num)
"Randomly signed num."
(let ((ran (random 2)))
(if (= ran 0) num (- num))))
;; (loop repeat 20 collect (sign-random 1)) => (-1 -1 1 1 1 1 1 1 -1 -1 -1 -1 -1 1 -1 1 1 -1 1 -1)
(defun split-random (num sort)
"split a value randomly in two numbers."
(let* ((rval (random (if (equal num 0) 1 num)))
(vrval (- num rval))
(mi (min rval vrval))
(ma (max rval vrval)))
(if (= sort 0) (list mi ma) (list ma mi))
;; when sort = 0 the min value is first, with sort = 1 its the other way round
))
;; (split-random 10 0) => (1 9)
;; (split-random 10 1) => (7 3)
;; (loop repeat 10 collect (split-random (random 10) (random 2))) => ((8 2) (5 5) (5 5) (4 6) (1 9) (5 5) (7 3) (7 3) (6 4) (4 6))
(defun lowpass-random (n)
"Linear random low-pass distribution (original code by Heinrich Taube)."
(min (random n) (random n)))
; (loop repeat 100 collect (lowpass-random 50))
#|
=> (42 18 20 43 23 9 3 8 0 27 10 15 18 1 44 7 8 5 21 12 0 6 1 13 12 12 8 14 2 9 42 14 14 28 11 2 19 4 25 1 2 9 34 23 10 3 10 22 11 13 27 25 15 26 21 0 29 0 12 13 31 9 7 28 9 3 3 8 2 6 25 45 2 14 19 14 47 21 4 40 26 34 1 2 0 22 18 25 24 17 16 12 12 5 15 2 27 11 21 6)
|#
(defun lowpass-random-q (n q)
"random-lowpass with variable filter-q."
(if (= q 0) (random n)
(loop repeat q collect (random n) into numberlist
finally (return (apply #'min numberlist)))))
; (loop repeat 50 collect (lowpass-random-q 50 0))
#|
=> (5 0 3 0 1 8 0 2 1 0 6 0 0 2 5 3 2 2 1 0 2 2 3 1 0 4 10 5 3 0 4 7 2 0 0 1 0 2 4 0 1 1 2 2 0 0 4 5 1 0)
|#
(defun highpass-random (n)
"Linear random high-pass distribution (original code by Heinrich Taube)."
(max (random n) (random n)))
; (loop repeat 100 collect (highpass-random 50))
#|
=> (30 36 32 11 34 23 48 47 21 44 46 22 24 7 7 43 23 43 17 33 10 40 47 31 36 22 17 49 18 46 23 30 43 33 47 27 18 24 41 48 37 6 34 40 26 39 25 44 16 38 44 43 30 43 18 32 35 44 38 28 36 32 5 29 45 5 46 27 37 35 23 17 42 46 49 47 28 41 38 35 30 23 29 6 44 39 48 23 6 5 45 42 40 21 23 37 28 39 7 20)
|#
(defun highpass-random-q (n q)
"Random-highpass with variable filter-q."
(if (= q 0) (random n)
(loop repeat q collect (random n) into numberlist
finally (return (apply #'max numberlist)))))
; (loop repeat 50 collect (highpass-random-q 50 20))
#|
=> (48 48 49 47 47 44 49 49 48 49 44 49 43 46 45 49 47 43 48 48 48 48 49 49 49
46 49 49 46 48 47 49 48 47 48 48 45 44 48 48 49 41 48 48 39 49 42 44 47 47)
|#
(defun choice (val1 val2 perc)
"Choose between val1 an val2 with perc = random percentage of val1."
(let ((r (random 100.0)))
(if (< r perc) val1 val2)))
;; (loop repeat 30 collect (choice 0 1 10)) => (0 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)
(defun norep-random (rep low high)
"Random without without equal consecutive numbers."
(loop until (= reslength rep)
with value and last-value
with reslength = 0 do
(setf last-value value
value (+ low (random (+ 1 (- high low)))))
when (not (equal value last-value))
collect value into resultlist and do
(setf reslength (length resultlist))
finally (return resultlist)))
;; (norep-random 10 0 10) => (2 6 1 9 2 3 9 2 6 3)
(defun norep-nth-random (rep lis)
"Random in list without equal consecutive numbers."
(loop until (= reslength rep)
with value and last-value
with reslength = 0 do
(setf last-value value
value (nth (random (length lis)) lis))
when (not (equal value last-value))
collect value into resultlist and do
(setf reslength (length resultlist))
finally (return resultlist)))
;; (norep-nth-random 10 '(1 2 3 4)) => (3 4 2 3 4 3 4 1 2 4)
;;; norep nth random mit mod12
;;; NOT WORKING WITH REPEATED ELEMENTS IN LIST E.G. '(4 4 4 5 5 5 6 6 6)
;; shuffle list
(defun shuffle (lis &optional (rep 1) &key (total NIL))
"Returns a list of the same with the elements randomly reordered"
(let* ((llis (length lis))
(end (if total rep (* rep llis))))
(loop with cdrlis and n
for i from 0 below end do
(when (zerop (mod i llis)) (setf cdrlis lis))
;; when modulo i from the length of lis is equal to 0
;; reset cdrlis to lis (see print)
(setf n (nth (random (length cdrlis)) cdrlis))
;; takes a random element from cdrlis and
(setf cdrlis (remove n cdrlis :count 1))
;; remove it
collect n)))
;; (shuffle '(1 2 3 4 5 6 7 8)) => (5 4 8 1 3 7 6 2)
;; (shuffle '(1 2 3 4 5 6 7 8) 2) => (2 1 5 4 6 3 7 8 6 5 3 8 4 7 2 1)
;; (shuffle '(1 2 3 4 5 6 7 8) 13 :total T) => (1 6 2 7 3 4 8 5 7 5 8 6 4)
(defun nshuffle (sequence)
"The Knuth shuffle (a.k.a. the Fisher-Yates shuffle) is an algorithm
for randomly shuffling the elements of an array:
https://www.rosettacode.org/wiki/Knuth_shuffle#Common_Lisp"
(loop for i from (length sequence) downto 2
do (rotatef (elt sequence (random i))
(elt sequence (1- i))))
sequence)
;; (nshuffle '(0 1 2 3 4 5)) => (3 0 2 1 5 4)
;; unique elements
(defun unique (lis &optional n)
"Returns n unique elements from lis"
(let* ((ls (remove-duplicates lis))
(llis (length ls))
(end (if n (min n llis) llis)))
(loop with n
with cdrlis = ls
for i from 0 below end do
(setf n (nth (random (length cdrlis)) cdrlis))
(setf cdrlis (remove n cdrlis))
collect n)))
;; (unique '(1 2 3 4 2 5 6 7 8)) => (5 7 8 2 1 6 4 3)
;; (unique '(1 2 3 4 5 3 6 7 8) 5) => (8 4 1 5 6)
(defun weighted-random (n weight-list)
"Returns a number of weighted random numbers. Weights are taken from
a list indicating <element> and <random percentage> in pairs."
(let ((wlis (loop for j from 0 below (- (length weight-list) 1) by 2
append
(make-list (nth (+ 1 j) weight-list)
:initial-element (nth j weight-list))
into reslis
finally (return reslis))))
(loop repeat n
collect (nth (random (- (length wlis) 1)) wlis))))
;; (weighted-random 10 '(1 10 2 20 3 70)) => (1 2 3 3 3 3 3 3 2 3)
(defun random-element (list)
"Return some element of the list, chosen at random."
(nth (random (length list)) list))
;; (random-element '(3 9 6 5 7 1 3 4 6 4 7 8)) => 9
(defun sample-with-replacement (n population)
(let ((result nil))
(dotimes (i n)
(push (nth (random (- (length population) 1)) population) result))
result))
;; (sample-with-replacement 10 '(1 2 3 4 5 6 7 8)) => (1 5 2 2 2 6 6 5 6 5)
(defun sample-without-replacement
(n population &optional (m (length population)))
; Assumes that m = (length population)
(cond ((<= n 0) nil)
((>= n m) population)
((>= (/ n m) (random 1.0))
(cons (first population) (sample-without-replacement
(- n 1) (rest population) (- m 1))))
(t (sample-without-replacement n (rest population) (- m 1)))))
;; (sample-without-replacement 10 '(1 2 3 4 5 6 7 8 9 10 11 12)) => (1 2 4 6 7 8 9 10 11 12)
(defun brownian-single-step (n stp weight start)
(let ((wlis (append
(make-list weight :initial-element stp)
(make-list (- 100 weight) :initial-element (* -1 stp)))))
(loop repeat n
with s = start
collect s into reslis
do (setf s (+ s (nth (random (- (length wlis) 1)) wlis)))
finally (return reslis))))
;; (brownian-single-step 10 1 40 10)
(defun brownian (n weight-list start)
(let ((wlis (loop for j from 0 below (- (length weight-list) 1) by 2
append
(make-list (nth (+ 1 j) weight-list)
:initial-element (nth j weight-list))
into reslis
finally (return reslis))))
(loop repeat n
with s = start
collect s into reslis
do (setf s (+ s (nth (random (- (length wlis) 1)) wlis)))
finally (return reslis))))
;; (brownian 40 '(1 30 -1 30 2 20 -2 20) 10)
(defun brownian-borders (n weight-list start low high)
"Arguments:
n - number of values to create
weight - a list of pairs of value and weight
start - starting value
low - low limit at which the motion is reflected
high - high limit at which the motion is reflected.
Example:
(brownian-borders 50 '(1 40 -1 60 2 20) 10 5 15)"
(let ((wlis (loop for j from 0 below (- (length weight-list) 1) by 2
append
(make-list (nth (+ 1 j) weight-list)
:initial-element (nth j weight-list))
into reslis
finally (return reslis))))
(loop repeat n
with s = start
do (setf s (if (< s low)
(+ low (abs (- s low)))
(if (> s high)
(- high (abs (- s high)))
s)))
collect s into reslis
do (setf s (+ s (nth (random (length wlis)) wlis)))
finally (return reslis))))
(defun random-sum1 (lst-sum low high)
"Collects random numbers between low and high until lst-sum. If the result is > lst sum
the last number is truncated to fit lst-sum."
(loop
with s
collect (+ low (random (- high low))) into reslis
do (setf s (reduce #'+ reslis))
until (>= s lst-sum)
finally (return
(if (> s lst-sum)
(append (butlast reslis)
(list (- lst-sum (reduce #'+ (butlast reslis)))))
reslis))))
;; (random-sum1 20 2 5)
(defun random-sum2 (lst-sum lis)
"Try to build a list containing the numbers in lis with the sum of lst-sum."
(loop
with sum
for x = (loop
with s
collect (nth (random (length lis)) lis) into reslis
do (setf s (reduce #'+ reslis))
until (>= s lst-sum)
finally (return reslis))
do (setf sum (reduce #'+ x))
do (print x)
until (= sum lst-sum)
finally (return x)))
;; (random-sum2 20 '(7 3 8))
;;; https://ccrma.stanford.edu/CCRMA/Courses/220b/Lectures/4/Examples/probability.lisp
;;; Some probability distributions
;; Uniform
(defun uniform ()
(random 1.0))
;; Linear
(defun linear ()
(let* ((ua (random 1.0))
(ub (random 1.0)))
(if (< ua ub) ua ub)))
;; Triangular
(defun triangular ()
(let* ((ua (random 1.0))
(ub (random 1.0)))
(* 0.5 (+ ua ub))))
;; Exponential
(defun exponential (delta)
(/ (- (log (random 1.0))) delta))
;; Bilateral exponential
(defun biexp (delta)
(let* ((val (random 2.0)))
(if (> val 1.0)
(/ (- (log val)) delta)
(- (/ (- (log (- 2.0 val))) delta)))))
;; Gaussian
(defun gaussian (sigma mu &optional (n 12))
(let* ((novr (/ n 2))
(scale (/ (sqrt (/ n 12))))
(sum (loop repeat n sum (random 1.0))))
(+ (* sigma scale (- sum novr)) mu))) | 14,075 | Common Lisp | .lisp | 312 | 39.660256 | 295 | 0.616025 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 0703158449390f124e647e594459ecbaf2059479b01bc8db761ef08dc116506d | 35,152 | [
-1
] |
35,153 | menus.lisp | bornhoeft_ab-lisp/lisp/menus.lisp | (in-package :ab-lisp)
;; user menu
(ccl::add-PWGL-user-menu
'(:menu-component
("ABLib"
(("Envelopes" (env-scale
sample-values
resample-x
split-xy
sample-env))
("Lists" (flat-last
list-intervals))
("Math"
("Average" (average
mean-deviation
arithmetic-mean
harmonic-mean
hoelder-mean
power-mean
)))
("Pitchclass" (pc?
oct?
same-pitchclass-chord
same-pc
pc-instances
pc-simple-mult))
("Quantisation" (index-no
quantize
quantize-list
quant-up
quant-down
which-quant
round-up
round-down
round-to
prev-measure
next-measure
closest-measure))
("Random" (rand))
("Utilities" (switch-pos-neg
rev-switch
between?
iota
half
median
semi-to-srate
sec-to-min
midi-to-integer
integer-to-midi
measure-to-quarter
quarter-to-measure
index-no
)))
)
)
)
| 1,526 | Common Lisp | .lisp | 56 | 12.089286 | 41 | 0.374573 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | eb2d6b49d4993af2e7c23981129a2d1c54d2a2f8390944dca9502b770bb5675a | 35,153 | [
-1
] |
35,154 | math.lisp | bornhoeft_ab-lisp/lisp/math.lisp | ;;; Copyright (c) 2009, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; arithmetic mean
;;; The measure of central tendency of a set of values computed by dividing the
;;; sum of the values by their number; commonly called the mean or the average.
;;; http://en.wikipedia.org/wiki/Arithmetic_mean
(defun average (numbers)
"Numerical average (mean) of a list of numbers."
(* 1.0 (/ (reduce #'+ numbers) (length numbers))))
;; (average '(1 2 3 4 5)) => 3
;; (average '(1 2 3 4 5 6 7 8 9 10)) => 5.5
;;; The average is carried out by dividing by N - 1 instead of N
(defun arithmetic-mean (lis)
(loop for x in lis
for n from 0
summing x into xx-sum
finally (return (* 1.0 (/ xx-sum n)))))
;; (arithmetic-mean '(1 2 3 4 5)) => 3.75
;; (arithmetic-mean '(1 2 3 4 5 6 7 8 9 10)) => 6.111111
#|
The mean deviation describes how far the i-th sample deviates (differs) from the mean. The average deviation of a signal is found by summing the deviations of all the individual samples, and then dividing by the number of samples, N. Notice that we take the absolute value of each deviation before the summation; otherwise the positive and negative terms would average to zero. The average deviation provides a single number representing the typical distance that the samples are from the mean. While convenient and straightforward, the average deviation is almost never used in statistics. This is because it doesn't fit well with the physics of how signals operate. In most cases, the important parameter is not the deviation from the mean, but the power represented by the deviation from the mean. For example, when random noise signals combine in an electronic circuit, the resultant noise is equal to the combined power of the individual signals, not their combined amplitude.
The standard deviation is similar to the average deviation, except the averaging is done with power instead of amplitude. This is achieved by squaring each of the deviations before taking the average (remember, power <221D> voltage2). To finish, the square root is taken to compensate for the initial squaring.
In the alternative notation: sigma = sqrt((x0 -<03BC>)2 + (x1 -<03BC>)2 + ... + (xN-1 -<03BC>)2 / (N-1)). Notice that the average is carried out by dividing by N - 1 instead of N. This is a subtle feature of the equation that will be discussed in the next section. The term, <03C3>2, occurs frequently in statistics and is given the name variance. The standard deviation is a measure of how far the signal fluctuates from the mean. The variance represents the power of this fluctuation.
|#
(defun deviation (number lis)
"Deviation of number from the mean of lis."
(sqrt (* 1.0 (expt (- number (/ (reduce #'+ lis) (length lis))) 2))))
;; (average '(1 2 3 4 5 6)) => 3.5
;; (deviation 2 '(1 2 3 4 5 6)) => 1.5
(defun mean-deviation (lis)
(loop for x in lis
for n from 1
for xx = (expt (- x (arithmetic-mean lis)) 2)
summing xx into xx-sum
finally (return (sqrt (/ xx-sum n)))))
;; (mean-deviation '(1 2 3 4 5 6 7 8 9 10)) => 2.9365723
;;; quadratic mean (root mean square)
;;; http://en.wikipedia.org/wiki/Root_mean_square
;;; A type of average, calculated as the square root of the mean of the squares. In contrary to the geometric mean higher values are favored.
(defun quadratic-mean (lis)
(loop for x in lis
for xx = (* x x)
for n from 1
summing xx into xx-sum
finally (return (sqrt (/ xx-sum n)))))
; (quadratic-mean '(1 2 3 4 5 6 7 8 9 10)) => 6.204837
;;; harmonic-mean
;;; http://en.wikipedia.org/wiki/Harmonic_mean
(defun harmonic-mean (lis)
(loop for x in lis
for n from 1
summing (/ 1.0 x) into xx-sum
finally (return (/ n xx-sum))))
; (harmonic-mean '(80 120))
; (harmonic-mean '(1 2 3 4 5 6 7 8 9 10)) => 3.4141712
;;; geometric mean
;;; (never higher than the arithmetic mean)
;;; http://en.wikipedia.org/wiki/Geometric_mean
(defun geometric-mean (lis)
(loop for x in lis
for n from 1
collect x into reslis
finally (return (expt (reduce #'* reslis) (/ 1 n)))
;; (sqrt 2) = (expt 2 (/ 1 2))
))
; (geometric-mean '(1.03 1.07))
; (geometric-mean '(1 2 3 4 5 6 7 8 9 10)) => 4.5287285
;;; hoelder mean
;;; p = 1 arithmetic, p = 2 quadric, p = -1 harmonic, p = 3 kubic
(defun hoelder-mean (lis &optional (p 1))
(loop for x in lis
for xx = (expt x p)
for n from 1
summing xx into xx-sum
finally (return (expt (/ xx-sum n) (/ 1.0 p)))))
; (hoelder-mean '(1 2 3 4 5 6 7 8 9 10)) => 5.5
; (hoelder-mean '(1 2 3 4 5 6 7 8 9 10) 2) => 6.204837
;;; power mean
;;; types: 'arithmetic, 'quadric, 'harmonic, 'kubic, default = 'arithmetic
(defun power-mean (lis &optional type)
(let ((p (case type
(:arithmetic 1)
(:quadric 2)
(:harmonic -1)
(:kubic 3)
(otherwise 1))))
(loop for x in lis
for xx = (expt x p)
for n from 1
summing xx into xx-sum
finally (return (expt (/ xx-sum n) (/ 1.0 p))))))
; (power-mean '(1 2 3 4 5 6 7 8 9 10)) => 5.5
; (power-mean '(1 2 3 4 5 6 7 8 9 10) :arithmetic) => 5.5
; (power-mean '(1 2 3 4 5 6 7 8 9 10) :quadric) => 6.204837
(defun diff (val1 val2)
"absolute difference between val1 and val2: (diff -1 5) => 6"
(abs (- val1 val2)))
;; (diff -1 5) => 6
(defun square (x) (* x x))
(defun round-off (number precision)
"Round off the number to specified precision. E.g. (round-off 1.23 .1) = 1.2"
(* precision (round number precision)))
;; (round-off 2.134253 .12)
;; (round-off 2.5 1)
(defun round-even (val)
"Round to the next even number."
(let ((rv (round val))
(dec (nth-value 1 (floor val))))
(if (and (oddp rv) (< rv val))
(+ val (- 1 dec))
(if (and (oddp rv) (> rv val))
(- val dec)
(if (oddp rv)
(* 1.0 (+ val 1))
rv)))))
;; (round-even 1.4) => 2
;; (round-even 0.9) => 0
;; (round-even 1) => 2
;; (round-even 0.8) => 0
;; (round-even 11.7) => 12
;; (round-even 5.5) => 6
;; (round-even 4.99) => 4
(defun root (n x)
"(root 12 2) => 1.0594632 (semitone)"
(expt x (/ 1 n)))
;; (root 12 2) => 1.0594632 (semitone)
;;; Golden Section
(defun *golden-number* ()
(/ (+ 1 (sqrt 5)) 2))
;; (*golden-number*) -> 1.618034
(defun gs (s &optional part)
(let ((gn (/ (+ 1 (sqrt 5)) 2)))
(case part
('major (/ s gn))
('minor (- s (/ s gn)))
(otherwise (* s gn)))))
;; (gs 1) => 1.618034
;; (gs 1 'major) => 0.618034
;; (gs 1 'minor) => 0.381966
;;; KEYS FUNKTIONIEREN NICHT IN BOX !???
(defun golden-section (s &optional p)
(if (numberp s) (gs s p)
(loop for i in s
collect (gs i p))))
;; (golden-section 1) => 1.618034
;; (golden-section '(1 2 3 4))
;; (golden-section '(1 2 3 4) 'major)
(defun percentage (p h)
"How much percent is p from h?"
(* h (/ p 100)))
;; (percentage 10 80) => 8
(defun percentage? (n h)
"How much is n in percent from h?"
(* 100 (/ n h)))
;; (percentage? 20 80) = 25
(defun hundred-percent? (n p)
"What is hundred percent when n is p percent ?"
(* 100 (/ n p)))
;; (hundred-percent? 20 10) => 200
;;; Greatest common divisor
;;; in lisp: (gcd 2345 5432) => 7
;;; http://rosettacode.org/wiki/Greatest_common_divisor#Common_Lisp
(defun gcd2 (a b)
"Greatest common divisor of 2 numbers."
(if (zerop b) a (gcd2 b (mod a b))))
;; (gcd2 2345 5432) => 7
(defun gcd-lst (lst)
"Greatest common divisor of numbers in lst."
(apply #'gcd lst))
;; (gcd-lst '(30 40 50)) => 10
(defun lcm2 (&rest args)
"Least common multiple of numbers."
(reduce (lambda (m n)
(cond ((or (= m 0) (= n 0)) 0)
(t (abs (/ (* m n) (gcd m n))))))
args :initial-value 1))
;; (lcm2 3 4 5 6) => 60
;; (lcm2 3 4 6) => 12
(defun lcm-lst (lst)
"Least common multiple of numbers in lst."
(apply #'lcm lst))
;; (lcm-lst '(1 2 3 4)) => 12
(defun cartesian-product (lists)
"Cartesian product of n equally long lists."
(labels ((distl (m N)
(cond
((null N) nil)
(t (cons (list m (car N))
(distl m (cdr N))))))
(cartesian (M N)
(cond
((null M) nil)
(t (append (distl (car M) N)
(cartesian (cdr M) N))))))
(reduce #'cartesian lists)))
;; (cartesian-product '((A B C) (1 2 3) (x y z)))
(defun decimals (number)
"Decimal numbers of a float."
(nth-value 1 (floor number)))
;; (decimals 5.432) -> 0.43200016
(defun residual (number divisor)
"Rest of an integer division."
(nth-value 1 (floor number divisor)))
;; (residual 17 5) -> 2
(defun g+ (val1 val2)
"Version of +. Both arguments can be numbers or lists"
(let* ((va1 (if (numberp val1) (list val1) val1))
(va2 (if (numberp val2) (list val2) val2))
(v1 (if (numberp val1) (loop repeat (length va2) collect val1) va1))
(v2 (if (numberp val2) (loop repeat (length va1) collect val2) va2)))
(loop for i in v1
for j in v2
collect (+ i j) into reslis
finally (return (if (equal (length reslis) 1)
(first reslis)
reslis)))))
;; (g+ 4 2) => 6
;; (g+ 2 4) => 6
;; (g+ 4 '(1 2 3)) => (5 6 7)
;; (g+ '(1 2 3) 4) => (5 6 7)
;; (g+ '(1 2 3) '(2 3 4)) => (3 5 7)
;; (g+ '(1 2 3) '(2 3)) => (3 5)
(defun g- (val1 val2)
"Version of -. Both arguments can be numbers or lists"
(let* ((va1 (if (numberp val1) (list val1) val1))
(va2 (if (numberp val2) (list val2) val2))
(v1 (if (numberp val1) (loop repeat (length va2) collect val1) va1))
(v2 (if (numberp val2) (loop repeat (length va1) collect val2) va2)))
(loop for i in v1
for j in v2
collect (- i j) into reslis
finally (return (if (equal (length reslis) 1)
(first reslis)
reslis)))))
;; (g- 4 2) => 2
;; (g- 2 4) => -2
;; (g- 4 '(1 2 3)) => (3 2 1)
;; (g- '(1 2 3) 4) => (-3 -2 -1)
;; (g- '(1 2 3) '(2 3 4)) => (-1 -1 -1)
;; (g- '(1 2 3) '(2 3)) => (-1 -1)
(defun g* (val1 val2)
"Version of *. Both arguments can be numbers or lists"
(let* ((va1 (if (numberp val1) (list val1) val1))
(va2 (if (numberp val2) (list val2) val2))
(v1 (if (numberp val1) (loop repeat (length va2) collect val1) va1))
(v2 (if (numberp val2) (loop repeat (length va1) collect val2) va2)))
(loop for i in v1
for j in v2
collect (* i j) into reslis
finally (return (if (equal (length reslis) 1)
(first reslis)
reslis)))))
;; (g* 4 2) => 8
;; (g* 2 4) => 8
;; (g* 4 '(1 2 3)) => (4 8 12)
;; (g* '(1 2 3) 4) => (4 8 12)
;; (g* '(1 2 3) '(2 3 4)) => (2 6 12)
;; (g* '(1 2 3) '(2 3)) => (2 6)
(defun g/ (val1 val2)
"Version of /. Both arguments can be numbers or lists"
(let* ((va1 (if (numberp val1) (list val1) val1))
(va2 (if (numberp val2) (list val2) val2))
(v1 (if (numberp val1) (loop repeat (length va2) collect val1) va1))
(v2 (if (numberp val2) (loop repeat (length va1) collect val2) va2)))
(loop for i in v1
for j in v2
collect (/ i j) into reslis
finally (return (if (equal (length reslis) 1)
(first reslis)
reslis)))))
;; (g/ 4 2) => 2
;; (g/ 2 4) => 1/2
;; (g/ 4.0 '(1 2 3)) => (4.0 2.0 1.3333334)
;; (g/ '(1 2 3) 4) => (1/4 1/2 3/4)
;; (g/ '(1 2 3) '(2 3 4)) => (1/2 2/3 3/4)
;; (g/ '(1 2 3) '(2 3)) => (1/2 2/3)
(defun round-ord (val)
(nth-value 0 (floor (+ val 1/2))))
;; (round-ord 3) => 3
;; (round-ord 2.5) => 3
;; (round-ord 2.7) => 3
;; (round-ord 2.3) => 2
(defun round-to (number precision &optional (fun #'round))
(let ((div (expt 10 precision)))
(/ (funcall fun (* number div)) div)))
;; The optional parameter "fun" can be one of #'floor, #'ceil, #'truncate
;; (round-to 1234.4567 0) => 1234
;; (round-to 1234.4567 1) => 2469/2
;; (float (round-to 1234.4567 1 #'floor)) => 1234.4
;; (float (round-to 1234.4567 1 #'ceiling)) => 1234.5
;; (float (round-to 1234.4567 2 #'truncate)) => 1234.45
;;; Factorial
;;; https://de.wikipedia.org/wiki/Fakultät_(Mathematik)
(defun fac (num)
"(fac 7) = 5040 = 1*2*3*4*5*6*7"
(let ((lis (loop for i from 1 to num collect i)))
(apply '* lis)))
;; (fac 7) = 5040 = 1*2*3*4*5*6*7
;;; Gaussche Summenformel
;;; https://de.wikipedia.org/wiki/Gaußsche_Summenformel
(defun gauss (num)
"(gauss 6) = 21 = 1+2+3+4+5+6"
(/ (* num (+ 1 num)) 2))
;; (gauss 6) = 21 = 1+2+3+4+5+6
(defun int-div (num)
"All possible integer divisions of num:
(int-div 42) => (1 2 3 6 7 14 21 42)"
(loop for i from num downto 1
for d = (/ num i)
when (integerp d)
collect d))
;; (int-div 68) => (1 2 4 17 34 68) | 14,195 | Common Lisp | .lisp | 332 | 38.084337 | 981 | 0.606606 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | aad87fd6a54c0b6e79a740b7fdd4bf3de231d96a52de7a149383283327f18544 | 35,154 | [
-1
] |
35,155 | quantisation.lisp | bornhoeft_ab-lisp/lisp/quantisation.lisp | ;;; Copyright (c) 2009, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; Quantisation
(defun index-no (val lis)
"Returns the list index of key in row."
(if (not (member val lis))
(format t "Value is not in list!")
(loop for i in lis
for y from 0 do
(when (= i val) (return y)))))
;; (index-no 4 '(3 24 5 76 1 99 49)) => NIL
;; (index-no 99 '(3 24 5 76 1 99 49)) => 5
(defun quant (num steps)
"Quantize a number to a defined step value (number or list of numbers)."
(labels ((index-no (val lis)
"Returns the list index of key in row."
(if (not (member val lis))
(format t "Value is not in list!")
(loop for i in lis
for y from 0 do
(when (= i val) (return y))))))
(let* ((stp (if (numberp steps) (list steps) steps))
(round-lis (loop for i in stp collect (* (round (/ num i)) i)))
(diff-lis (loop for i in round-lis collect (abs (- i num))))
(smallest (apply #'min diff-lis)))
(nth (index-no smallest diff-lis) round-lis))))
;; (quant 5.231 '(.5 .2 .25)) => 5.25
;; (quant 5.342 .6) => 5.4
;; (loop for i in '(1 1.2 3 5.5 6.4 7.6 7.8 5.4 6.1 9.5) collect (quant i 0.4))
;; => (0.8 1.2 3.2 5.6 6.4 7.6 8.0 5.6 6.0 9.6)
;; (loop for i in '(1 1.2 3 5.5 6.4 7.1 7.8 5.4) collect (* 1.0 (quant i 1/7)))
;; => (1.0 1.1428572 3.0 5.428571 6.428571 7.142857 7.857143 5.428571)
;; (quant 1 0.4) => 0.8 because (round (/ 1.0 0.4)) => 2, 0.5
(defun quant-list (lis steps)
"Quantisation of a list to a defined step value (number or list of numbers."
(loop for i in lis collect (quant i steps)))
;; (quant-list '(1.25346 5.43765) 0.5)
(defun raster (lis quant-lis)
(loop for i in lis collect
(loop for j in quant-lis
collect (abs (- i j)) into reslis
finally (return (nth (position (apply #'min reslis) reslis) quant-lis)))))
#|
(raster '(1/12 5/27 31/108 7/18 53/108 16/27 25/36 43/54 97/108 1)
'(1/12 1/10 1/9 1/8 1/7 1/6 1/5 1/4 1/3 1/2 1 2 3 4))
=> (1/12 1/5 1/4 1/3 1/2 1/2 1/2 1 1 1)
|#
(defun quant-up (num step)
(let ((q (* (round (/ num step)) step)))
(if (< q num) (+ q step) q)))
;; (quant-up 2.2 .5) => 2.5
(defun quant-down (num step)
(let ((q (* (round (/ num step)) step)))
(if (> q num) (- q step) q)))
;; (quant-down 2.2 .5) => 2.0
;; (quant-down 2.5 .6) => 2.0
(defun which-quant (num steps)
"returns the closest quantization from a list of steps"
(let* ((stp (if (number? steps) (list steps) steps))
(round-lis (loop for i in stp collect (quant num i)))
(diff-lis (loop for i in round-lis collect (abs (- i num))))
(smallest (apply #'min diff-lis)))
(list-ref stp (index-no diff-lis smallest))))
;; (which-quant 5.456 '(.5 .2 .25)) => 0.5
(defun round-up (val)
"round up value"
(let ((r (round val)))
(if (< r val) (+ r 1) r)))
;; (round-up 10.125) => 11
(defun round-down (val)
"round down value"
(let ((r (round val)))
(if (> r val) (- r 1) r)))
;; (round-down 7.99) => 7
(defun round-to (val nextval)
""
(let ((r (round val))
(v (- nextval 1)))
(if (< r val) (- r v) (+ r v))))
;; (round-to 2.3 2) => 1
;; (round-to 2.7 2) => 4
(defun next-measure (time quarters)
"calculates from the current time the time of the next measure start. (quarters = quarters per measure)"
(let* ((b (round-up (/ time quarters)))
(c (/ b quarters))
(d (* quarters c)))
(* d quarters)))
;; (next-measure 19.2 4) => 20
;; (next-measure 19.2 3) => 21
(defun prev-measure (time quarters)
"calculates from the current time the time of the previous measure start. (quarters = quarters per measure)"
(let* ((b (round-down (/ time quarters)))
(c (/ b quarters))
(d (* quarters c)))
(* d quarters)))
;; (prev-measure 19.2 4) => 16
;; (prev-measure 14.76 3) => 12
(defun closest-measure (time quarters)
"calculates from the current time the time of the closest measure start. (quarters = quarters per measure)"
(let* ((dif-next (diff time (next-measure time quarters)))
(dif-prev (diff time (prev-measure time quarters)))
(closest (min dif-next dif-prev)))
(if (= closest dif-next) (+ time dif-next) (- time dif-prev))))
;; (closest-measure 14.1 4) => 16.0
;; (closest-measure 13.9 4) => 12.0
;; (closest-measure 14.156 3) => 15.0
| 5,545 | Common Lisp | .lisp | 126 | 41.087302 | 112 | 0.640645 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 0d18d9c0c0bff32dbce24e4e9ad0a9a83d884cff3d6fd9f385d1c987db8236b4 | 35,155 | [
-1
] |
35,156 | package.lisp | bornhoeft_ab-lisp/lisp/package.lisp | (defpackage :ab-lisp
(:use :cl))
(in-package :ab-lisp)
(eval-when (:execute :compile-toplevel :load-toplevel)
(import '(ccl::PWGLdef) :ab-lisp))
| 150 | Common Lisp | .lisp | 5 | 28 | 54 | 0.694444 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 23859b513239faaba808011e676bf5ab9d9f83d0fbef8c39f32e62c1b2b354c5 | 35,156 | [
-1
] |
35,157 | envelopes.lisp | bornhoeft_ab-lisp/lisp/envelopes.lisp | ;;; Copyright (c) 2009-2015, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; Envelope functions
(defun env-scale (dur xylist &key (scale 1))
"envelope from list of x/y values in specified duration"
(let* ((llis (length xylist)))
(loop for y from 0 to (- llis 1) by 2
collect (* dur (nth y xylist))
collect (* scale (nth (+ 1 y) xylist)))))
;; (env-scale 100 '(0 0.2 0.5 0.8 0.8 0.2 1 0.1) :scale 10) => (0 2.0 50.0 8.0 80.0 2.0 100 1.0)
(defun sample-values (start end samples)
"Any number of equidistant values between start an end."
(let ((qnt (/ 1 (- samples 1)))
(dif (abs (- end start))))
(loop repeat samples
for i from 0 by qnt
collect (* 1.0 (+ start (* i dif))))))
;; (sample-values 20 60 9) => (20.0 25.0 30.0 35.0 40.0 45.0 50.0 55.0 60.0)
;; (sample-values 21 60.5 8) => (21.0 26.642857 32.285713 37.928574 43.57143 49.214287 54.857143 60.5)
(defun resample-x (lst samples)
"Resample a list of x-values to any number of equidistant x-values in the same range."
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect i)))
;; (loop for i in (resample-x '(0 1 2 3) 5) collect (* 1.0 i)) => (0.0 0.75 1.5 2.25 3.0)
;; (loop for i in (resample-x '(0 1 2 3) 6) collect (* 1.0 i)) => (0.0 0.6 1.2 1.8 2.4 3.0)
;; (loop for i in (resample-x '(0 1 2 4) 6) collect (* 1.0 i)) => (0.0 0.8 1.6 2.4 3.2 4.0)
;; (loop for i in (resample-x '(0 1 2 4 5 8) 6) collect (* 1.0 i)) => (0.0 1.6 3.2 4.8 6.4 8.0)
;; (loop for i in (resample-x '(1 2.5 4.5 5 7.5) 5) collect (* 1.0 i)) => (1.0 2.625 4.25 5.875 7.5)
(defun map-range (a1 a2 b1 b2 s)
"Calculates the value s according to a range between
a1 and a2 into a new range between b1 and b2."
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1)))))
;; Envelope with xy-values: '(1 23 3 30)
;; Which value at x = 2.5 ? => 28,243
;; (map-range 1 3 0 1 2.5) => 0.75
;; (map-range 0 1 23 30 0.75) => 28,25 !!!
;; (map-range 1 3 0 1 1) => 0.00
;; (map-range 0 1 23 30 0) => 23.0
;; (map-range 1 4 0 1 2) => 0.33333334
;; (map-range 0 1 5 3 0.3333334) => 4.333333
(defun split-xy (lst)
"Split a list of x/y-values into a list of x-values and a list of y-values."
(loop for i from 0 to (- (length lst) 1) by 2
for j from 1 by 2
collect (nth i lst) into xlis
collect (nth j lst) into ylis
finally (return (list xlis ylis))))
;; (split-xy '(1 23 3 30 4 40)) => ((1 3 4) (23 30 40))
#|
(defun sample-env-x (env samples)
(labels ((resample-x (lst samples)
"Resample a list of x-values to any number of
equidistant x-values in the same range."
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect i)))
(map-range (a1 a2 b1 b2 s)
"Calculates the value s according to a range
between a1 and a2 into a new range between b1 and b2."
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(let* ((xlst (first env))
(ylst (second env))
(rs-x (resample-x xlst samples)))
(loop for i in rs-x
collect
(loop
for x in xlst
for xc in (cdr xlst)
for y in ylst
for yc in (cdr ylst)
for r1 = (map-range x xc 0 1 i)
for r2 = (map-range 0 1 y yc r1)
when (>= xc i x) do (return r2))
into results
finally (return (list rs-x results))))))
;; (sample-env-x '((0 1 2 3) (1 3 2 4)) 5) => ((0 3/4 3/2 9/4 3) (1.0 2.5 2.5 2.5 4.0))
;; (sample-env-x '((0 2 3 5) (1 3 2 4)) 5) => ((0 5/4 5/2 15/4 5) (1.0 2.25 2.5 2.75 4.0))
(defun sample-env-xy (env samples)
(labels ((split-xy (lst)
"Split a list of x/y-values into a list
of x-values and a list of y-values."
(loop for i from 0 to (- (length lst) 1) by 2
for j from 1 by 2
collect (nth i lst) into xlis
collect (nth j lst) into ylis
finally (return (list xlis ylis))))
(resample-x (lst samples)
"Resample a list of x-values to any number of
equidistant x-values in the same range."
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect i)))
(map-range (a1 a2 b1 b2 s)
"Calculates the value s according to a range
between a1 and a2 into a new range between b1 and b2."
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(let* ((xy (split-xy env))
(xlst (first xy))
(ylst (second xy))
(rs-x (resample-x xlst samples)))
(loop for i in rs-x
collect i into results
collect
(loop
for x in xlst
for xc in (cdr xlst)
for y in ylst
for yc in (cdr ylst)
for r1 = (map-range x xc 0 1 i)
for r2 = (map-range 0 1 y yc r1)
when (>= xc i x) do (return r2))
into results
finally (return results)))))
;; (sample-env-xy '(0 1 1 3 2 2 3 4) 5) => (0 1.0 3/4 2.5 3/2 2.5 9/4 2.5 3 4.0)
(defun sample-env (env samples)
"Taking any number of samples from an envelope of x/y-values.
Envelope can be a list of xy-value pairs or a list containing
a list of x-values and a list of y-values."
(labels ((split-xy (lst)
"Split a list of x/y-values into a list of x-values
and a list of y-values."
(loop for i from 0 to (- (length lst) 1) by 2
for j from 1 by 2
collect (nth i lst) into xlis
collect (nth j lst) into ylis
finally (return (list xlis ylis))))
(resample-x (lst samples)
"Resample a list of x-values to any number of
equidistant x-values in the same range."
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect (* 1.0 i))))
(map-range (a1 a2 b1 b2 s)
"Calculates the value s according to a range between
a1 and a2 into a new range between b1 and b2."
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(let* ((type? (numberp (first env)))
(xy (if type? (split-xy env)))
(xlst (if type? (first xy) (first env)))
(ylst (if type? (second xy) (second env)))
(rs-x (resample-x xlst samples)))
(loop for i in rs-x
when type? collect i into results
collect
(loop
for x in xlst
for xc in (cdr xlst)
for y in ylst
for yc in (cdr ylst)
for r1 = (map-range x xc 0 1 i)
for r2 = (map-range 0 1 y yc r1)
when (>= xc i x) do (return r2))
into results
finally (if type? (return results) (return (list rs-x results)))))))
;; (sample-env '(0 1 1 3 2 2 3 4) 5)
;; => (0.0 1.0 0.75 2.5 1.5 2.5 2.25 2.5 3.0 4.0)
;; (sample-env '((0 1 2 3) (1 3 2 4)) 5)
;; => ((0.0 0.75 1.5 2.25 3.0) (1.0 2.5 2.5 2.5 4.0))
|#
(defun sample-env (env samples &key type)
"Taking any number of samples from an envelope of x/y-values.
Envelope can be a list of xy-value pairs or a list containing
a list of x-values and a list of y-values. Output is the same
format as the input by default. It can be declared with the
type keyword :xy = 1 list, :x-y = 2 lists."
(labels ((split-xy (lst)
"Split a list of x/y-values into a list of x-values
and a list of y-values."
(loop for i from 0 to (- (length lst) 1) by 2
for j from 1 by 2
collect (nth i lst) into xlis
collect (nth j lst) into ylis
finally (return (list xlis ylis))))
(resample-x (lst samples)
"Resample a list of x-values to any number of
equidistant x-values in the same range."
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect (* 1.0 i))))
(map-range (a1 a2 b1 b2 s)
"Calculates the value s according to a range between
a1 and a2 into a new range between b1 and b2."
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(let* ((type? (numberp (first env)))
;; if type? T then its a xy-list otherwise 2 lists.
(xy (if type? (split-xy env)))
(xlst (if type? (first xy) (first env)))
(ylst (if type? (second xy) (second env)))
(rs-x (resample-x xlst samples)))
(loop for i in rs-x
for j = (loop
for x in xlst
for xc in (cdr xlst)
for y in ylst
for yc in (cdr ylst)
for r1 = (map-range x xc 0 1 i)
for r2 = (map-range 0 1 y yc r1)
when (>= xc i x) do (return r2))
collect i into results
collect j into results
collect j into y-lis
finally (case type
(:xy (return results))
(:x-y (return (list rs-x y-lis)))
(otherwise
(if type?
(return results)
(return (list rs-x y-lis)))))))))
;; (sample-env '(0 1 1 3 2 2 3 4) 5)
;; => (0.0 1.0 0.75 2.5 1.5 2.5 2.25 2.5 3.0 4.0)
;; (sample-env '((0 1 2 3) (1 3 2 4)) 5)
;; => ((0.0 0.75 1.5 2.25 3.0) (1.0 2.5 2.5 2.5 4.0))
;; (sample-env '(0 1 1 3 2 2 3 4) 5 :type :x-y)
;; => ((0.0 0.75 1.5 2.25 3.0) (1.0 2.5 2.5 2.5 4.0))
;; (sample-env '((0 1 2 3) (1 3 2 4)) 5 :type :xy)
;; =>(0.0 1.0 0.75 2.5 1.5 2.5 2.25 2.5 3.0 4.0)
| 12,085 | Common Lisp | .lisp | 267 | 35.153558 | 102 | 0.527839 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | a5fc363ebece75d39ff3816d27392c0cc4470c0adc6429b89dc207e666393e08 | 35,157 | [
-1
] |
35,158 | pitchclass.lisp | bornhoeft_ab-lisp/lisp/pitchclass.lisp | ;;; Copyright (c) 2009, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;; Pitchclass
(defun pc? (keys)
"Pitch class from keys."
(let ((k (if (listp keys) keys (list keys))))
(loop for i in k collect (mod i 12))))
;; (pc? '(60 61 62 63 64 65 66 67 68 69 70 71 72)) => (0 1 2 3 4 5 6 7 8 9 10 11 0)
;; (pc? '(45 78 67 89 34 56 90 60)) => (9 6 7 5 10 8 6 0)
(defun oct? (keys)
"Pitch class from keys."
(let ((k (if (listp keys) keys (list keys))))
(loop for i in k collect (floor (/ i 12)))))
;; (oct? '(5 17 29 41 53 65 77 89 101 113)) => (0 1 2 3 4 5 6 7 8 9)
;; (oct? '(45 78 67 89 34 56 90 22 11 112)) => (3 6 5 7 2 4 7 1 0 9)
(defun same-pitchclass-chord (keys pc)
"Collect and sort all keys of a given pitchclass (or list of pitchclasses) in a row of keynumbers."
(let ((class (if (listp pc) pc (list pc))))
(sort (loop for y in class append
(loop for i in keys
for p = (mod i 12)
when (= p y) collect i)) '<)))
;; (same-pitchclass-chord '(45 78 67 89 34 56 90 60 101) 5) => (89 101)
;; (same-pitchclass-chord '(45 78 67 89 34 56 90 60 101) '(5 6)) => (78 89 90 101)
;;; PWGL Box [same-pc]
(defun same-pitchclass (keys pc)
"Collect and sort all keys of a given pitchclass (or list of pitchclasses) in a row of keynumbers."
(let ((class (if (listp pc) pc (list pc))))
(loop for y in class collect
(sort (loop for i in keys
for p = (mod i 12)
when (= p y) collect i) '<))))
;; (same-pitchclass '(45 78 67 89 34 56 90 60 101) 5) => ((89 101))
;; (same-pitchclass '(45 78 67 89 34 56 90 60 101) '(5 6)) => ((89 101) (78 90))
(defun pc-instances (lis)
""
(let ((chord (sort (loop for i in lis collect (+ 60 (mod i 12))) #'<)))
(loop repeat (length chord)
with ls = chord
collect ls into reslis
do (setq ls (append (cdr ls) (list (+ 12 (car ls)))))
finally (return reslis))))
(defun pc-simple-mult (lis1 lis2)
(let ((l1 (loop for i in lis1
collect (loop for x in i
collect (- x (first i)))))
(l2 (loop for i in lis2
collect (loop for x in i
collect (- x (first i))))))
(append
(loop for i in l1
collect (loop for x in i
append (mapcar #'(lambda (y)
(+ 60 (mod (+ x y) 12))) (first lis2)) into outlis
finally (return (remove-duplicates outlis))))
(loop for i in l2
collect (loop for x in i
append (mapcar #'(lambda (y)
(+ 60 (mod (+ x y) 12))) (first lis1)) into outlis
finally (return (remove-duplicates outlis)))))))
| 3,817 | Common Lisp | .lisp | 80 | 44.1 | 101 | 0.651694 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 8291e2b7a8e1b25f16ae0f83114cd1a9d600dd247271663c1f2c7f52b3a1b8b8 | 35,158 | [
-1
] |
35,159 | spectral.lisp | bornhoeft_ab-lisp/lisp/spectral.lisp | ;;; Copyright (c) 2009-2015, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; Spectral functions
;;; code from: http://subsynth.sourceforge.net/midinote2freq.html
(defun midi-to-hertz (midi)
(* (/ 440 32) (expt 2 (/ (- midi 9) 12))))
;; (midi-to-hertz 60) => 261.62555
;;; code from: http://www.musicdsp.org/showone.php?id=125
(defun hertz-to-midi (hertz &optional (precision 1))
"Convert hertz to midi, precision 1 = semtiones, 0.5 = quartertones."
(* 1.0 precision (round (+ 69.0 (* 12 (log (/ hertz 440) 2))) precision )))
;; (hertz-to-midi 220) => 57
;; (hertz-to-midi 454.536 4) => 70
;; (hertz-to-midi 454.536 0.5) => 69.5
;; (hertz-to-midi 454.536 1/3) => 69.666664
#|
To convert hertz to milliseconds, first determine the duration or period of one vibration by dividing one second by the frequency in hertz. For example, for a 500 Hz signal, the duration of one cycle is 1/500 or .002 seconds. To convert this figure to milliseconds, multiply it by 1,000. From the example, .002 seconds * 1,000 = 2 milliseconds. Each cycle in a 500 Hz signal takes 2 milliseconds to complete. Read more : http://www.ehow.com/how_6608111_convert-hertz-milliseconds.html
|#
(defun hz2msec (freq)
"Convert hertz to milliseconds"
(* 1000 (/ 1 freq)))
;; (hz2msec 500) => 2
(defun harmonic-delay (fundamental partials &optional (scale 1.0))
(loop for i from 1 to partials
collect (* 1000.0 (/ scale (* fundamental i)))))
;; (harmonic-delay 100 8 ) => (10.0 5.0 3.3333335 2.5 2.0 1.6666667 1.4285715 1.25)
;; (harmonic-delay 100 8 10) => (100.0 50.0 33.333336 25.0 20.0 16.666668 14.285714 12.5)
(defun subharmonic-delay (fundamental partials &optional (scale 10))
(loop for i from 1 to partials
collect (/ fundamental (/ scale i))))
;; (subharmonic-delay 100 8) => (10 20 30 40 50 60 70 80)
;; (subharmonic-delay 220 8 1) => (220 440 660 880 1100 1320 1540 1760)
| 3,185 | Common Lisp | .lisp | 52 | 59.5 | 484 | 0.724326 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 342b654373c17a7489d7c4fb343a392136731361b972f982b84da683ad1a8a5a | 35,159 | [
-1
] |
35,160 | lists.lisp | bornhoeft_ab-lisp/lisp/lists.lisp | ;;; Copyright (c) 2009-2015, Achim Bornhoeft. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :ab-lisp)
;;; List functions
(defun first-length (lis)
(length (first lis)))
;; (first-length '((1 2 3 4 3 5 6) (3 6 4 5 7) (3 6 4 7 3))) => 7
(defun flatten (obj)
"http://rosettacode.org/wiki/Flatten_a_list#C ommon_Lisp"
(do* ((result (list obj))
(node result))
((null node) (delete nil result))
(cond ((consp (car node))
(when (cdar node) (push (cdar node) (cdr node)))
(setf (car node) (caar node)))
(t (setf node (cdr node))))))
;; (flatten '((1 2 (3 4) 3 5 6) (3 6 ((4 5)) 7))) => (1 2 3 4 3 5 6 3 6 4 5 7)
(defun flat-length (lis)
(labels ((flatten (obj)
"http://rosettacode.org/wiki/Flatten_a_list#Common_Lisp"
(do* ((result (list obj))
(node result))
((null node) (delete nil result))
(cond ((consp (car node))
(when (cdar node) (push (cdar node) (cdr node)))
(setf (car node) (caar node)))
(t (setf node (cdr node)))))))
(length (flatten lis))))
;; (flat-length '((1 2 (3 4) 3 5 6) (3 6 ((4 5)) 7) (3 6 4 7 3))) => 17
(defun flat-last-list (lis)
"remove additional parentheses until the last list"
(let ((l lis))
(loop while (= (length l) 1) do
(setq l (first l))
finally (return l))))
;; (flat-last-list '(((1 2) (3 4) (5 6)))) => ((1 2) (3 4) (5 6))
(defun flat-once (lis)
(append (car lis) (cdr lis)))
;; (flat-once '(((c4 cs4 d4) (ds4 e4 f4 fs4) (g4 gs4) (a4 as4 b4))));;
(defun sum-zerop (lis)
(if (= (reduce '+ lis) 0) t nil))
;; (sum-zerop '( -2 3 5 -1 -3 -2)) => T
;; (sum-zerop '( -2 3 5 -3 -2)) => NIL
(defun range (lis min max)
"range a list between min and max."
(let ((minlis (reduce #'min lis))
(maxlis (reduce #'max lis)))
(labels ((map-range (a1 a2 b1 b2 s)
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(loop for i in lis
collect (map-range minlis maxlis min max i)))))
;; (range '(1 2 3 4 5) 1 2) => (1.0 1.25 1.5 1.75 2.0)
;; (range '(1 3 6 7) 1 2) => (1.0 1.3333334 1.8333334 2.0)
;; (range '(2 3 6 4 5 8 6 7) 2 3) => (2.0 2.1666667 2.6666667 2.3333333 2.5 3.0 2.6666667 2.8333333)
(defun scaling-max (lis new-max)
(let* ((max-value (apply #'max lis))
(mult-factor (/ new-max max-value)))
(loop for i in lis
collect (* mult-factor i))))
;; (scaling-max '(1 2 3 4 5 6) 10.0) => (1.6666666 3.3333333 5.0 6.6666665 8.333333 10.0)
(defun scaling-sum (lis new-sum)
(let* ((sum (reduce #'+ lis))
(sum-factor (/ new-sum sum)))
(loop for i in lis
collect (* sum-factor i))))
;; (scaling-sum '(1 2 3 4 5) 30.0) => (2.0 4.0 6.0 8.0 10.0)
;; (reduce #'+ (scaling-sum '(1 2 3 4 5) 30.0)) => 30.0
;; (reduce #'+ (scaling-sum '(4 6 5 8 7 11 2 3 4.5 11.2) 100.0)) => (6.482982 9.724473 8.103727 12.965964 11.345219 17.828201 3.241491 4.8622365 7.293355 18.15235)
(defun scale-list (lst scale-sum &key (rounded nil))
"
Scale all numbers of lst to a given sum.
Examples:
(scale-list '(1 2 3 4 5) 25)
=> (1.6666666 3.3333333 5.0 6.6666665 8.333333)
Proof: (sum (scale-list '(1 2 3 4 5) 25)) => 25.0
With rounded numbers:
(scale-list '(1 2 3 4 5) 25 :rounded t) => (2 3 5 7 8)
"
(let ((result
(loop for i in lst
collect (* 1.0 (* scale-sum
(/ i (reduce '+ lst)))))))
(if rounded (mapcar 'round result)
result)))
(defun lengths (ls)
"Returns the length of <ls>. <ls> can be a list of lists."
(if (numberp (first ls))
(length ls)
(mapcar #'length ls)))
;; (lengths '((1 2 3 4) (2 3 4 5 6 2))) => (4 6)
;; (lengths '(1 2 3 4)) => 4
(defun length-rest (lis id)
"calculate the rest length of a list from a given index (including the index)"
(let* ((max-id (length lis)))
(if (> id max-id)
(format t "List is shorter than the given index!")
(if (< id 0)
(format t "Negative index!")
(- max-id id)))))
;; (length-rest '(1 2 3 4 5 6 7 8 9) 5) => 4
;; (length-rest '(1 2 3 4 5 6 7 8 9) -5) => NIL (Negative index!)
;; (length-rest '(1 2 3 4 5 6 7 8 9) 10) => NIL (list is shorter than the given index!)
(defun sublist (lis index int)
"calculates the rest list of lis from a given id with length int (maximal the length-rest)"
(let ((reps (min int (length-rest lis index))))
(loop repeat reps
for i from index
collect (list-ref lis i))))
;; (sublist '(2 3 4 5 6 7 8 9) 3 12) => (5 6 7 8 9)
;; (sublist '(3 2 4 5 6 9 8 0 7 1) 3 6) => (5 6 9 8 0 7)
(defun nth? (e ls)
(if (numberp (member e ls))
(error "Element is not in list.")
(loop for i in ls
for j from 0
when (equal i e) return j)))
;; (nth? 7 '(3 5 2 6 4 7 8)) => 5
;; Lisp: (position 7 '(3 5 2 6 4 7 8)) => 5
;; Lisp: (elt '(3 5 2 6 4 7 8) 5) => 7
(defun intervals (lis interv start)
"returns the indexes in a list for with a specific interval (interv).
Example: (intervals '(50 45 56 62 67) 5 1)"
(labels (( nth? (e ls)
(if (numberp (member e ls))
(error "Element is not in list.")
(loop for i in ls
for j from 0
when (equal i e) return j))))
(loop for y in lis
for z from 0
for stval = (nth start lis)
for i = (+ y interv)
when (>= y stval)
when (member i lis) collect (list z (nth? i lis)))))
;; (intervals '(50 45 56 62 67 68) 5 1) => ((1 0) (3 4))
(defun interval-in-list (lis interv &optional (start 0))
"collects all values in a specific interval from a given position in a list"
(loop for y in lis
for stval = (nth start lis)
when (= (mod (- y stval) interv) 0)
collect y))
;; (interval-in-list '(45 78 67 89 34 56 90 22 11 112) 5) => (45 90)
;; (interval-in-list '(45 78 67 89 34 56 90 22 11 112) 5 2) => (67 22 112)
(defun remove-sequent (lis)
"remove same sequent numbers."
(let ((last nil))
(loop for i in lis
when (not (equal last i)) collect i into reslis
do (setf last i)
finally (return reslis))))
;; (remove-sequent '(2 3 4 5 5 6 7 5 8)) => (2 3 4 5 6 7 5 8)
(defun modulo-reflect (lis x)
""
(let ((plis (append lis (reverse (cdr (butlast lis))))))
(nth (mod (abs x) (length plis)) plis)))
;; (loop for i from -5 to 9 collect (modulo-reflect '(1 2 3 4 5) i))
;; => (4 5 4 3 2 1 2 3 4 5 4 3 2 1 2)
(defun make-element-list (lis)
(loop for j from 0 below (- (length lis) 1) by 2
append (make-list (nth (+ 1 j) lis) :initial-element (nth j lis)) into reslis
finally (return reslis)))
; (make-element-list '(1 4 2 5 3 6)) => (1 1 1 1 2 2 2 2 2 3 3 3 3 3 3)
(defun last-elt (list)
"Return the last element of a list."
(first (last list)))
(defun left-rotate (list)
"Move the first element to the end of the list."
(append (rest list) (list (first list))))
(defun right-rotate (list)
"Move the last element to the front of the list."
(append (last list) (butlast list)))
(defun transpose-matrix (list-of-lists)
"Transpose a matrix represented as a list of lists.
Example: (transpose '((a b c) (d e f))) => ((a d) (b e) (c f))."
(apply #'mapcar #'list list-of-lists))
(defun insert-between (item list)
"Insert item between every element of list."
(if (or (null list) (length=1 list))
list
(list* (first list) item (insert-between item (rest list)))))
(defun fibonacci-sum (n)
"Tail-recursive Fibonacci number function"
(labels ((calc-fib (n a b)
(if (= n 0)
a
(calc-fib (- n 1) b (+ a b)))))
(calc-fib n 0 1)))
;; (fibonacci-sum 40) => 102334155
(defun count-all (lst)
"count the number of different elements according to their position
in lst."
(let ((rd-lst (remove-duplicates lst :test #'equalp)))
(mapcar #'(lambda (x) (count x lst)) rd-lst)))
;; (count-all '(3 4 2 5 5 7 6 8 3 4 2 5 1 6 4 7)) => (1 2 2 3 1 2 3 2)
(defun identical-lists? (lis1 lis2)
"compares if two lists are identical"
(loop for i in lis1
for j in lis2
collect (equal i j) into reslis
finally (return (if (member nil reslis) nil t))))
;; (identical-lists? '(1 2 3 4) '(1 2 3 4)) => t
;; (identical-lists? '(1 2 3 4) '(1 2 5 4)) => nil
(defun different-lists? (lis1 lis2)
"compares if two lists are different"
(loop for i in lis1
for j in lis2
collect (equal i j) into reslis
finally (return (if (member nil reslis) t nil))))
;; (different-lists? '(1 2 3 4) '(1 2 3 4)) => nil
;; (different-lists? '(1 2 3 4) '(1 2 5 4)) => t
;; (different-lists? '(1 2 3 4) '(2 1 3 4)) => t
(defun opposite-lists? (lis1 lis2)
"Compares if two lists are opposite.
(Each element of lis1 with the same index in lis2 is different.)."
(if (numberp (first lis2))
(loop for i in lis1
for j in lis2
collect (equal i j) into reslis
finally (return (if (member t reslis) nil t)))
(loop for i in lis2
append
(loop for j in i
for k in lis1
collect (equal i j)) into reslis
finally (return (if (member t reslis) nil t)))))
;; (opposite-lists? '(1 2 3 4) '(3 1 4 2)) => t
;; (opposite-lists? '(1 2 3 4) '(4 2 1 3)) => nil
;; (opposite-lists? '(1 2 3 4) '((3 1 4 2) (4 3 2 1) (2 4 1 3))) => t
(defun x-dx (ls)
"Returns the list of the intervals between the contiguous values of a list <ls>. <ls> can also be a list of lists of intervals. Used convert notes to intervals."
(labels ((x-dx-fun (lst)
(loop for i in lst
for j in (cdr lst)
collect (- j i))))
(if (numberp (first ls))
(x-dx-fun ls)
(mapcar #'x-dx-fun ls))))
;; (x-dx '(0.5 0.5 0.25 0.25 0.25 0.3)) => 0.0 -0.25 0.0 0.0 0.050000012)
;; (x-dx '((0.5 0.5 0.25) (0.25 0.25 0.3))) => ((0.0 -0.25) (0.0 0.050000012))
(defun dx-x (ls &optional (st 0))
"Constructs a list of numbers from <start> with the consecutives intervals of <ls>.
<ls> can also be a list of lists of intervals. Used convert rhythms to entry points."
(labels ((dx-x-fun (ls &optional (st 0))
(let ((r st))
(loop for i in ls
for n = (+ r i)
collect n into reslis
do (setf r n)
finally (return (cons st reslis))))))
(if (numberp (first ls))
(dx-x-fun ls st)
(loop for i in ls collect (dx-x-fun i st)))))
;; (dx-x '(0.5 0.5 0.25 0.25 0.25 0.3)) => (0 0.5 1.0 1.25 1.5 1.75 2.05)
;; (dx-x '(0.5 0.5 0.25 0.25 0.25 0.3) 3) => (3 3.5 4.0 4.25 4.5 4.75 5.05)
;; (dx-x '((0.5 0.5) (0.25 0.25 0.25 0.3)) 3) => ((3 3.5 4.0) (3 3.25 3.5 3.75 4.05))
(defmacro sort-lists (lists &key (sort-id 'first))
`(sort (copy-seq ,lists) #'< :key #',sort-id))
;; (setq testlis '((0) (1) (2) (0 1 5) (0 1 3) (0 1 5) (0 3 0) (0) (1) (2 7 19) (0 0 3 0)))
;; (sort-lists testlis) => ((0) (0 1 5) (0 1 3) (0 1 5) (0 3 0) (0) (0 0 3 0) (1) (1) (2) (2 7 19))
;; (sort-lists '((3 4) (2 7) (6 3) (1 7))) => ((1 7) (2 7) (3 4) (6 3))
;; (sort-lists '((0 1 5)(0 1 3)(0 1 5)(0 3 0)(2 7 19) (0 0 3 0)) :sort-id second) => ((0 0 3 0) (0 1 5) (0 1 3) (0 1 5) (0 3 0) (2 7 19))
(defun list-permute (lis permutation)
"Calculates a permutation (positive or negative) of a list."
(let ((ln (length lis)))
(loop for i from 0 to (- ln 1)
for k from permutation
collect (nth (mod k ln) lis))))
;; (list-permute '(1 2 3 4 5 6) 0) => (1 2 3 4 5 6)
;; (list-permute '(1 2 3 4 5 6) 2) => (3 4 5 6 1 2)
;; (list-permute '(1 2 3 4 5 6) -2) => (5 6 1 2 3 4)
(defun permute-list (lis &optional (start-permutation 0) (permutations 1) (dir :fw))
"Calculates permutations of a list given a start-permutation, the number of permutations and the directions of this permustions: forward (:fw) or backward (:bw)."
(labels ((list-permute (lis permutation)
(let ((ln (length lis)))
(loop for i from 0 to (- ln 1)
for k from permutation
collect (nth (mod k ln) lis)))))
(case dir
(:fw
(loop repeat permutations
for i from start-permutation
if (= permutations 1)
append (list-permute lis i)
else
collect (list-permute lis i)))
(:bw
(loop repeat permutations
for i downfrom start-permutation
if (= permutations 1)
append (list-permute lis i)
else
collect (list-permute lis i)))
(otherwise (error "Wrong direction specifier!")))))
;; (permute-list '(1 2 3 4 5 6)) => (1 2 3 4 5 6)
;; (permute-list '(1 2 3 4 5 6) 2) => (3 4 5 6 1 2)
;; (permute-list '(1 2 3 4 5 6) 2 4) => ((3 4 5 6 1 2) (4 5 6 1 2 3) (5 6 1 2 3 4) (6 1 2 3 4 5))
;; (permute-list '(1 2 3 4 5 6) 2 3 :bw) => ((3 4 5 6 1 2) (2 3 4 5 6 1) (1 2 3 4 5 6))
;; (permute-list '(1 2 3 4 5 6) 2 4 :back) => > Error: Wrong direction specifier!
(defun number-of-elements (lis)
"Compute the number of different elements in a list
and returns a list of lists containing
the element and the number of occurrences."
(let ((l (sort (remove-duplicates lis) #'<)))
(loop for i in l
collect (list i (count i lis)))))
;; (number-of-elements (print (loop for i from 1 to 20 collect (random 10)))) =>
;; (7 2 7 6 5 2 0 6 0 9 9 6 4 1 3 1 7 5 6 2)
;; ((0 2) (1 2) (2 3) (3 1) (4 1) (5 2) (6 4) (7 3) (9 2))
;;; Median
;;; The Median is the 'middle number' (in a sorted list of numbers).
(defun median (lis &key type)
"Middle number in a list."
(let* ((len (length lis))
(slis (sort lis '< ))
(half (/ len 2)))
(if (oddp len)
(nth (/ (- len 1) 2) slis)
(case type
('virtual (/ (+ (nth (- half 1) slis) (nth half slis)) 2.0))
(otherwise (list (nth (- half 1) slis) (nth half slis)))))))
;; (median '(5 2 4 1 3)) => 3
;; (median '(5 2 4 1 3 6)) => 3 4
;; (median '(5 2 4 1 3 6) :type 'virtual) => 3.5
(defun half-minmax (lis)
"The middle value of min and max in a list."
(let ((mi (apply #'min lis))
(ma (apply #'max lis)))
(/ (+ mi ma) 2.0)))
;; (half-minmax '(4 3 6 5 7 8 2 9 1 10)) => 5.5
;; (half-minmax '(0 4 3 6 5 7 8 2 9 1 10)) => 5.0
(defun normalise-list (lis)
"Normalize the sum of a list to 1."
(let ((sum-lis (reduce #'+ lis)))
(loop for i in lis collect (* 1.0 (/ i sum-lis)))))
;; (normalise-list '(3 4 2 5 6)) => (0.15 0.2 0.1 0.25 0.3)
;; (reduce #'+ (normalise-list '(3 4 2 5 6))) => 1.0
(defun palindrome (lis &key double)
(if double (append lis (reverse lis))
(append lis (cdr (reverse lis)))))
;; (palindrome '(1 2 3 4 5)) => (1 2 3 4 5 4 3 2 1)
;; (palindrome '(1 4 2 5 3 6)) => 1 4 2 5 3 6 3 5 2 4 1)
;; (palindrome '(1 4 2 5) :double t) => (1 4 2 5 5 2 4 1)
;; (palindrome (loop for i from 1 to 4 collect i)) => (1 2 3 4 3 2 1)
(defun trans-mat (list-of-lists)
"transpose a matrix represented as a list of lists.
Example: (trans-mat '((a b c) (d e f))) => ((a d) (b e) (c f))."
(apply #'mapcar #'list list-of-lists))
(defun shift-cut-lst (lst shift numb)
(loop repeat shift
with reslis = lst
do (setf reslis (butlast (append (list numb) reslis)))
finally (return reslis)))
;; (shift-cut-lst '(1 2 3 4 5) 1 1) ; => (1 1 2 3 4)
;; (shift-cut-lst '(1 2 3) 1 0) => (0 1 2)
(defun shift-ext-lst (lst shift numb)
(loop repeat shift
with reslis = lst
do (setf reslis (append (list numb) reslis))
finally (return reslis)))
;; (shift-ext-lst '(1 2 3 4 5) 2 1) ; => (1 1 1 2 3 4 5)
;; (shift-ext-lst '(5 4 3) 1 0) => (0 5 4 3)
(defun shift-replace-lst (lst shift numb)
(let ((ones (loop repeat shift collect numb)))
(append ones (subseq lst shift))))
;; (shift-replace-lst '(1 2 3) 2 0) => (0 0 3)
(defun replace-nth (n val lis)
"Replace position <n> with <val> in <lis>."
(loop for i from 0
for j in lis
collect (if (= i n) val j)))
;; (replace-nth 1 10 '(1 2 3 4 5 6 7)) => (1 10 3 4 5 6 7)
(defun sequencep (x)
(or (listp x) (vectorp x)))
(defun listsp (l)
(and (sequencep l) (every #'sequencep l)))
(defun maybe-map (function sequence &rest more-sequences)
"Determines if the sequence is a nested sequence, and if so,
maps the function across the subsequences."
(if (listsp sequence)
(apply #'map (class-of sequence) function sequence more-sequences)
(apply function sequence more-sequences)))
(defun signum-reduce (length)
(maybe-map (lambda (pattern)
(prog (out element store previous)
(setf previous (signum (car pattern)))
(setf store 0)
loop
(cond ((null pattern)
(push store out)
(return (nreverse out))))
(setf element (car pattern))
(cond ((not (= previous (signum element)))
(push store out)
(setf store 0)
(setf previous (signum element))))
(setf store (+ store element))
(pop pattern)
(go loop)))
length))
;; (signum-reduce '(-1 -1 1 1 1 1 -1 -1))
(defun divide-range (start end samples &key rounded)
"n equally spaced samples between (including) start and end."
(loop repeat samples
with >stnd = (> start end)
with st = (if >stnd end start)
with nd = (if >stnd start end)
with step = (/ (- nd st) (- samples 1))
with counter = st
collect (if rounded (round counter) counter) into reslis
do (setf counter (+ counter step))
finally (return (if >stnd (reverse reslis) reslis))))
;; (divide-range 59.0 83.5 8)
;; => (59.0 62.5 66.0 69.5 73.0 76.5 80.0 83.5)
;; (divide-range 83.5 59.0 8)
;; => (83.5 80.0 76.5 73.0 69.5 66.0 62.5 59.0)
;; (divide-range 59.0 83.5 8 :rounded t) ; => (59 62 66 70 73 76 80 84)
;; (divide-range 83.5 59.0 8 :rounded t) ; => (84 80 76 73 70 66 62 59)
#|
(loop
with lst = (divide-range 59.0 83.5 8)
for i in lst
for j in (cdr lst)
collect (- j i))
=> (3.5 3.5 3.5 3.5 3.5 3.5 3.5)
|#
(defun group-number (num grp)
"Make a list with grp numbers fitting in num. If grp does not fit
in num the last entry in the list is respectively reduced."
(let* ((rest (rem num grp))
(div (/ (- num rest) grp)))
(loop repeat div
collect grp into reslis
finally (return
(if (zerop rest)
reslis
(reverse (cons rest reslis)))))))
;; (group-number 12 3) => (3 3 3 3)
;; (group-number 12 4) => (4 4 4);;
;; (group-number 10 4) => (4 4 2)
;; (group-number 11 3) => (3 3 3 2)
(defun group-list (inlis grps)
"Groups list into subsequences, where grps indicates the length of each sublist.
Grps can be a number or a list of numbers.
If inlis is not exhausted by grps, the remaining values are ignored.
If inlis is exceeded by grps, the last group is respectively shortened."
(labels
((dx-x (ls &optional (st 0))
"Constructs a list of numbers from <start> with the consecutives intervals of <ls>."
(let ((r st))
(loop for i in ls
for n = (+ r i)
collect n into reslis
do (setf r n)
finally (return (cons st reslis)))))
(group-number (num grp)
"Make a list with grp numbers fitting in num.
If grp does not fit in num the last entry in the list is respectively reduced."
(let* ((rest (rem num grp))
(div (/ (- num rest) grp)))
(loop repeat div
collect grp into reslis
finally (return
(if (zerop rest)
reslis
(reverse (cons rest reslis))))))))
(let* ((ll (length inlis))
(pl (if (numberp grps)
(dx-x (group-number ll grps))
(dx-x grps))))
(loop
for i in pl
for j in (cdr pl)
collect (subseq inlis i (if (> j ll) ll j))))))
;; (group-list '(1 2 3 4 5 6 7 8 9) 3) => ((1 2 3) (4 5 6) (7 8 9))
;; (group-list '(1 2 3 4 5 6 7 8 9) 2) => ((1 2) (3 4) (5 6) (7 8) (9))
;; (group-list '(1 2 3 4 5 6 7 8 9) 4) => ((1 2 3 4) (5 6 7 8) (9))
;; (group-list '(1 2 3 4 5 6 7 8 9) 10) => ((1 2 3 4 5 6 7 8 9))
;; (group-list '(1 2 3 4 5 6 7 8 9) '(3 3 3)) => ((1 2 3) (4 5 6) (7 8 9))
;; (group-list '(1 2 3 4 5 6 7 8 9) '(2 3 4)) => ((1 2) (3 4 5) (6 7 8 9))
;; (group-list '(1 2 3 4 5 6 7 8 9) '(2 3 6)) => ((1 2) (3 4 5) (6 7 8 9))
;; (group-list '(1 2 3 4 5 6 7 8 9) '(2 3 2)) => ((1 2) (3 4 5) (6 7))
(defun replace-in-list (lis rep)
(labels
((replace-nth (n val lis)
"Replace position <n> with <val> in <lis>."
(loop for i from 0
for j in lis
collect (if (= i n) val j))))
(loop repeat rep
for ll = (length lis)
with ls = lis
collect ls into reslis
do (setf ls (replace-nth (random ll) (random ll) ls))
finally (return reslis))))
;; (replace-in-list '(1 2 3 4 5 6 7) 10)
(defun list-transform (rep lis count)
(labels
((replace-nth (n val lis)
"Replace position <n> with <val> in <lis>."
(loop for i from 0
for j in lis
collect (if (= i n) val j)))
(shuffle (lis &optional (rep 1) &key (total NIL))
"Returns a list of the same with the elements randomly reordered"
(let* ((llis (length lis))
(end (if total rep (* rep llis))))
(loop with cdrlis and n
for i from 0 below end do
(when (zerop (mod i llis)) (setf cdrlis lis))
(setf n (nth (random (length cdrlis)) cdrlis))
(setf cdrlis (remove n cdrlis))
collect n))))
(let* ((ll (length lis))
(cnt (if (numberp count) (list count) count))
(idlis (loop for i from 0 below ll collect i)))
(loop repeat rep
with ls = lis
for cnt-ran = (nth (random (length cnt)) cnt)
for shuffle-ids = (shuffle idlis)
collect ls into reslis
do (loop for i from 0 below cnt-ran
do (setf ls (replace-nth (nth i shuffle-ids) (random ll) ls)))
finally (return reslis)))))
;; (list-transform 3 '(1 2 3 4 5 6 7) 1)
;; => ((1 2 3 4 5 6 7) (1 4 3 4 5 6 0) (1 4 3 4 0 6 3))
(defun nestedp (lists)
(if (listp (second lists)) t
nil))
;; (nestedp '(1 2 3 4 5)) => nil
;; (nestedp '((1 2 3 4 5) nil)) => t
;; (nestedp '((1 2 3 4 5) (6 7 8 9))) => t
(defun cycle (lis rep &key (abs nil))
""
(loop repeat rep
for i from 0
if abs
collect (nth (mod i (length lis)) lis)
else
append lis
end))
;; (cycle '(1 2 3 4) 3) => (1 2 3 4 1 2 3 4 1 2 3 4)
;; (cycle '(1 2 3 4) 11 :abs t) => (1 2 3 4 1 2 3 4 1 2 3)
(defun member? (m lst)
(if (member m lst) t nil))
;; (member? 'a '(b 3 45 a c)) => t
;; (member? '10 '(b 3 45 a c)) => nil
;; (member? '10 '(b 3 45 a 10)) => t
(defun members (mlsts lsts)
(let ((ml (if (numberp (first mlsts)) (list mlsts) mlsts))
(ll (if (numberp (first lsts)) (list lsts) lsts)))
(loop for i in ml collect
(loop for m in ll collect
(loop for j in i collect
(if (member j m) t nil) into reslis
finally (return (if (member nil reslis) nil t)))) into result
finally (return (if (equal (length result) 1)
(first result)
result)))))
;; (members '(1 2) '(1 2 3 4 5)) => (t)
;; (members '((1 2) (3 7)) '((1 2 3 4 5) (4 5 6 7 8))) => ((t nil) (nil nil))
;; (members '(1 2) '((1 2 3 4 5) (4 5 6 7 8))) => (t nil)
;; (members '((1 2) (3 7)) '(1 2 3 4 5)) => ((t) (nil))
(defun members2 (mlsts lsts)
(let ((ml (if (numberp (first mlsts)) (list mlsts) mlsts))
(ll (if (numberp (first lsts)) (list lsts) lsts)))
(loop for i in ml collect
(remove nil (loop for m in ll collect
(loop for j in i collect
(if (member j m) t nil) into reslis
finally (return (when (not (member nil reslis))
(first m)))))) into result
finally (return (if (equal (length result) 1)
(first result)
result)))))
;; (members2 '((1 2) (4 7)) '((1 2 3 4 5) (4 5 6 7 8)))
(defun trim-list-sum (lst sum &key (pos nil))
(let* ((lsum (reduce #'+ (mapcar #'abs lst)))
(dif (- sum lsum))
(tst (minusp dif))
(val (if tst
(round (+ sum dif))
dif)))
(if (not (zerop dif))
(append lst (list
(* (if pos 1 -1)
(if tst
(- dif (* -1 val))
dif))))
lst)))
;; (trim-list-sum '(-0.25 0.25 0.25 0.25 0.25) 1)
;; => (-0.25 0.25 0.25 0.25 0.25 -0.75) sum old list > 1 => new list sum 2
;; (trim-list-sum '(-0.25 0.25) 1)
;; => (-0.25 0.25 0.5) sum old list < 1 => new list sum 1
;; (trim-list-sum '(-0.25 0.25 0.25 -0.25) 1)
;; => (-0.25 0.25 0.25 -0.25) sum old list = 1 => new list sum 1
;; (trim-list-sum '(-0.25 0.25 0.25 0.25 0.25) 1 :pos t)
;; (-0.25 0.25 0.25 0.25 0.25 0.75) added value positive
(defun half-list (lists &key gsh)
"Split list in half, making 2 lists. With odd numbered list,
the first half is one element longer than the second."
(let ((ll (if (listp (first lists)) lists (list lists))))
(loop for i in ll
for len = (length i)
for hlen = (/ len 2)
for flen = (floor hlen)
for clen = (ceiling hlen)
if (= len 1)
collect i and collect ()
else
if (evenp len)
collect (subseq i 0 hlen) and collect (subseq i hlen)
else
if gsh ; greater second half
collect (subseq i 0 flen) and collect (subseq i flen)
else
collect (subseq i 0 clen) and collect (subseq i clen))))
;; (half-list '((1) (2 3 4 5) (3 4 5 6 7) (7 5 8 7 9 0 34)))
;; (half-list '((1) (2 3 4 5) (3 4 5 6 7)) :gsh t)
(defun how-many (lst1 lst2)
"How many times an elements from the first list
occur in the second list?
EXAMPLE:
(how-many '(1 2 3 4) '(1 3 4 3 5)) => (1 0 2 1)"
(loop for i in lst1
collect
(loop for j in lst2
with count = 0
when (= j i)
do (setf count (+ 1 count))
finally (return count))))
(defun similarity (lst1 lst2)
"Sum all similarities between the first
and the second list.
EXAMPLE: (similarity '(1 2 3 4) '(1 3 4 3 5)) => 4"
(reduce #'+
(loop for i in lst1
collect
(loop for j in lst2
with count = 0
when (= j i)
do (setf count (+ 1 count))
finally (return count)))))
;;; only keyword item and position
(defun position-insert-seq (&key list insert item)
(let ((pos (car (position-item item alist))))
(position-replace (gen-integer pos (+ pos (1- (length insert)))) insert alist)))
(setf alist '(0 0 0 0 0 0 1 0 2 0 0 0 3 5 7))
(setf insert '(a b c d))
(position-insert-seq :list '(0 0 0 0 0 0 1 0 2 0 0 0 3 5 7)
:insert '(a b c d)
:item 2)
=> (0 0 0 0 0 0 1 0 a b c d 3 5 7)
| 28,491 | Common Lisp | .lisp | 674 | 36.007418 | 166 | 0.561725 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | c4098b7b0592a5bf1b90b15f032cb3922a3f9655107a90d7335fd306d137b2db | 35,160 | [
-1
] |
35,176 | sieves.pwgl | bornhoeft_ab-lisp/tutorial/TODO/sieves.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 389 :Y 106 :WIDTH 1018 :HEIGHT 946) :VALUE-STRING ";;; Sieve functions
;;; Modelled after Christopher Ariza
;;; The Xenakis Sieve as Object: A New Model and a Complete Implementation
;;; Computer Music Journal, 29:2, pp. 40<2013>60, Summer 2005
(in-package :cl-user)
(defun erastosthenes-sieve ()
(loop for i from 2 to 7
collect
(loop for y from (expt i 2) to 50 by i
collect y)))
; (erastosthenes-sieve)
(defun sieve (modulus shift maximum)
(when (> modulus 0)
(loop for i from shift to maximum by modulus collect i)))
; (sieve 3 0 50)
(defun sieves (residual-classes maximum)
(loop for i from 0 to (- (length residual-classes) 2) by 2
for modulus = (nth i residual-classes)
for shift = (nth (+ 1 i) residual-classes)
collect (sieve modulus shift maximum)))
; (sieves '(3 0 4 0) 50)
(defun sieves-union (residual-classes maximum)
(loop for i from 0 to (- (length residual-classes) 2) by 2
for modulus = (nth i residual-classes)
for shift = (nth (+ 1 i) residual-classes)
append (sieve modulus shift maximum) into reslis
finally (return (sort (remove-duplicates reslis) #'<))))
; (sieves-union '(3 0 4 0) 50)
(defun sieves-union-intervals (residual-classes maximum)
(let ((s (sieves-union residual-classes maximum)))
(loop for i in s
for j in (cdr s)
collect (abs (- j i)))))
; (sieves-union-intervals '(3 0 4 0) 50)
(defun sieves-union-binary (residual-classes maximum)
(let ((s (sieves-union residual-classes maximum)))
(loop for j from (apply #'min s) to (apply #'max s)
collect (if (member j s) 1 0))))
; (sieves-union-binary '(3 0 4 0) 50)
;;; --------------------------- TODO ----------------------- ;;;
(defun sieves-intersect (residual-classes maximum)
(loop for i from 0 to (- (length residual-classes) 2) by 2
for modulus = (nth i residual-classes)
for shift = (nth (+ 1 i) residual-classes)
collect (sieve modulus shift maximum) into reslis
finally (return (loop for j from 0 to (- (length residual-classes) 2)
for k = (nth j reslis)
with l = (nth (+ j 1) reslis)
collect (intersection k l) into interlis
do (setf l interlis)
finally (return interlis)))))
; (sieves-intersect '(3 0 4 0 5 0) 50)
")) :X 0.5479999999999996D0 :Y 1.424D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "periods" :CURVAL 2 :VALUE-STRING "2" :ARG-NAME (QUOTE PERIODS) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "modlis" :CURVAL (LIST 3 4) :VALUE-STRING "(3 4)" :ARG-NAME (QUOTE MODLIS) :ARG-TYPE :VAR)) :X 0.9480000029802316D0 :Y 1.3199999970197674D0 :W 0.26 :H 0.2 :BOX-STRING "sieve-period" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :TEXT "(iter (for i in modlis)
(with p = (* periods (apply #'lcm modlis)))
(appending
(iter (for y from 0 to p by i)
(collect y)) into reslis)
(finally (return (sort (remove-duplicates reslis) #'<))))")) :X 5 :Y 5 :X 5 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 4,146 | Common Lisp | .l | 61 | 60.557377 | 919 | 0.643317 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 72aaecc107937c59ad44ea16b219bc31ec03f57cf429c817de7b9df563ea7897 | 35,176 | [
-1
] |
35,177 | midis_no_export.pwgl | bornhoeft_ab-lisp/tutorial/TODO/midis_no_export.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-331)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 331)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.6600000000000006D0 :Y 1.287999536514283D0 :W 0.325 :H 0.39439997 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :R 1.0 :G 1.0 :B 1.0) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM) :INPUT-DRAW-MODE :PW-DOUBLE-INPUTS :CURRENT-EXTENSION-PATTERN-INDEX* 4) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.074999997019769D0 :Y 0.0839995245933558D0 :W 0.52 :H 0.099999994 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-ENP-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE ENP-CONSTRUCTOR-FUNCTION) :CURVAL 5 :MINVAL 0 :MAXVAL 6 :MENU-LIST :ENP-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":chord") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "pitches" :CURVAL (LIST 60) :VALUE-STRING "(60)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-UPDATE-MENUBOX-SUBVIEW) :BOX-STRING "keyarg" :PWGL-ACTION-FUNCTION (QUOTE UPDATE-NEXT-SUBBOX) :CURVAL 10 :MINVAL 0 :MAXVAL 12 :MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-1 :MENU-LIST-STRING ":start-time" :UPDATE-MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-2) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "arg" :STEPVAL 0.1 :MINVAL 0.0 :VALUE-STRING "0.0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-UPDATE-MENUBOX-SUBVIEW) :BOX-STRING "keyarg" :PWGL-ACTION-FUNCTION (QUOTE UPDATE-NEXT-SUBBOX) :CURVAL 4 :MINVAL 0 :MAXVAL 12 :MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-1 :MENU-LIST-STRING ":duration" :UPDATE-MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-2) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "arg" :CURVAL 0.125 :STEPVAL 0.1 :MINVAL 0.0 :MAXVAL 100.0 :VALUE-STRING "0.125" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-UPDATE-MENUBOX-SUBVIEW) :BOX-STRING "keyarg" :PWGL-ACTION-FUNCTION (QUOTE UPDATE-NEXT-SUBBOX) :CURVAL 1 :MINVAL 0 :MAXVAL 12 :MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-1 :MENU-LIST-STRING ":channel" :UPDATE-MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-2) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "arg" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1" :CONNECTION NIL)) :X 0.5679999999999992D0 :Y 0.5119995365142831D0 :W 0.4400000119209291D0 :H 0.2899999997764824D0 :BOX-STRING "enp-chord-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2 2 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 24 :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-CHORD-CONSTRUCTOR) :OPEN-STATE-W 0.4400000119209291D0 :OPEN-STATE-H 0.2899999997764824D0 :CURRENT-EXTENSION-PATTERN-INDEX* 3) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.4959999999999996D0 :Y 0.8240000934600835D0 :W 0.26 :H 0.01 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.01) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sequence" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 1.4360000000000004D0 :Y 1.2919998016357424D0 :W 0.26 :H 0.01 :BOX-STRING "length" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LENGTH) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.01) (MAKE-INSTANCE (QUOTE SCORE-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-SCORE-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE ENP-APPLICATION-WINDOW) :FIRST-MEASURE-NUMBER 6 :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :Y 100.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE CHORD-SEQUENCE) :X 4.0 :WIDTH 95.0 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :DURATION 0.96000004 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 63 :DUR 0.96 :TOTAL-DUR 0.96))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.6 :DURATION 0.90000004 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 57 :DUR 0.9 :TOTAL-DUR 0.9 :CHAN 2))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.1 :DURATION 0.84000004 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 52 :DUR 0.84 :TOTAL-DUR 0.84 :CHAN 3))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.5 :DURATION 0.09 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 48 :DUR 0.09 :TOTAL-DUR 0.09 :CHAN 4))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.65 :DURATION 0.63 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 46 :DUR 0.63 :TOTAL-DUR 0.63))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.7 :DURATION 0.6 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 46 :DUR 0.6 :TOTAL-DUR 0.6 :CHAN 2))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.7 :DURATION 0.060000003 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 48 :DUR 0.06 :TOTAL-DUR 0.06 :CHAN 3))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.7999997 :DURATION 0.09 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 52 :DUR 0.09 :TOTAL-DUR 0.09 :CHAN 4))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.95 :DURATION 0.33 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 57 :DUR 0.33 :TOTAL-DUR 0.33))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.3 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 63 :DUR 0.3 :TOTAL-DUR 0.3 :CHAN 2))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.0 :DURATION 0.120000005 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 67 :DUR 0.12 :TOTAL-DUR 0.12 :CHAN 3))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.2 :DURATION 0.120000005 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.12 :TOTAL-DUR 0.12 :CHAN 4))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.4 :DURATION 0.060000003 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 54 :DUR 0.06 :TOTAL-DUR 0.06))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.5 :DURATION 0.060000003 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 50 :DUR 0.06 :TOTAL-DUR 0.06 :CHAN 2))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.6 :DURATION 0.18 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 47 :DUR 0.18 :TOTAL-DUR 0.18 :CHAN 3))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.900001 :DURATION 0.120000005 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 47 :DUR 0.12 :TOTAL-DUR 0.12 :CHAN 4))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.1 :DURATION 0.060000003 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 50 :DUR 0.06 :TOTAL-DUR 0.06))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.200001 :DURATION 0.060000003 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 54 :DUR 0.06 :TOTAL-DUR 0.06 :CHAN 2))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.300001 :DURATION 0.120000005 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.12 :TOTAL-DUR 0.12 :CHAN 3))) (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.500001 :DURATION 0.3 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 67 :DUR 0.3 :TOTAL-DUR 0.3 :CHAN 4)))) :PIXELS/SEC 31.166666)))) :X 150 :Y 150 :TITLE "Score-Editor2" :X 150 :Y 150 :WIDTH 1185 :HEIGHT 742))) WIN) :CONNECTION NIL)) :X 1.1680000000000006D0 :Y -0.14000031661987267D0 :W 0.37999998807907076D0 :H 0.32 :BOX-STRING "Score-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "score") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "rtms/times")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SCORE-EDITOR) :OPEN-STATE-W 0.37999998807907076D0 :OPEN-STATE-H 0.32) (MAKE-INSTANCE (QUOTE GM-INSTRUMENT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :CURVAL 6 :MINVAL 0 :MAXVAL 7 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Harpsichord" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 2 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :CURVAL 2 :MINVAL 0 :MAXVAL 6 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Vibraphone" :CURVAL2 2 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 3 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "3") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :CURVAL 3 :MINVAL 0 :MAXVAL 6 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Marimba" :CURVAL2 2 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 4 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "4") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 7 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 5 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "5") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 8 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Timpani" :CURVAL2 3 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) :X 1.6480000000000002D0 :Y -0.1320003166198731D0 :W 0.7079999952316283D0 :H 0.33440000057220454D0 :BOX-STRING "gm-instrument" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2 2 2 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2) :EXTENSION-LIMIT 32 :X-PROPORTIONS (LIST (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5) (LIST 2 5)) :BORDER 0.012) :PW-FUNCTION (QUOTE GM-INSTRUMENT) :OPEN-STATE-W 0.7079999952316283D0 :OPEN-STATE-H 0.33440000057220454D0 :CURRENT-EXTENSION-PATTERN-INDEX* 4 :CURRENT-EXTENSION-PATTERN-INDEX 3 :STORED-EXTEND-INPUTS-LIST (LIST (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)) (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "chan" :CURVAL 1 :MINVAL 1 :MAXVAL 128 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "ins" :MINVAL 0 :MAXVAL 13 :MENU-LIST :GMIDI-NAME-LIST :MENU-LIST-STRING "Acoustic_Grand_Piano" :CURVAL2 4 :MENU-TITLES :GMIDI-TITLE-NAME-LIST :MAXVAL2 13)))) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "63 57 52 48 46 46 48 52 57 63 67 60 54 50 47 47 50 54 60 67")) :X 0.3520000000000003D0 :Y 1.8719997863769536D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX)) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-BOX) :R 0.65 :G 0.65 :B 0.65 :X 1.112000186920167D0 :Y 1.2999997863769535D0 :W 0.26 :H 0.021999999776482593D0 :BOX-STRING "rt-seq" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.021999999776482593D0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "start" :VALUE-STRING "0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "dxs" :CURVAL (LIST 1 1) :VALUE-STRING "(1 1)" :CONNECTION NIL)) :X 0.4359999999999995D0 :Y 0.44800032043456906D0 :W 0.2279999809265143D0 :H 0.1 :BOX-STRING "dx->x" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:DX->X) :OPEN-STATE-W 0.2279999809265143D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 0.6 :VALUE-STRING "0.6")) :X 0.8120000000000003D0 :Y 0.42400009346008183D0 :W 0.27999998092651346D0 :H 0.0840000014901161D0 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*) :OPEN-STATE-W 0.27999998092651346D0 :OPEN-STATE-H 0.0840000014901161D0) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "16.0 15.0 14.0 1.5 10.5 10.0 1.0 1.5 5.5 5.0 2.0 2.0 1.0 1.0 3.0 2.0 1.0 1.0 2.0 5.0 3.0 1.0 2.0 2.0 0.5 1.5 2.0 3.0 0.5 1.5 1.0 1.0 1.5 0.5 2.5 1.5 1.5 0.5 2.0 2.0 1.0 2.0 2.0 12.0 13.0 1.0 2.0 2.0 1.0 2.0 2.0 0.5 1.5 1.5 0.5 0.5 1.5 1.0 1.0 1.5 0.5 1.0 1.5 0.5 5.0 7.0 2.0 1.0 2.0 2.0 1.0 1.0 2.0 2.0 1.0 2.0 8.0 6.0 0.5 1.5 1.0 0.5 1.5 1.0 1.0 1.5 0.5 1.0 1.5 0.0 1.5 1.0 0.5 1.5 1.0 1.0 1.5 0.5 1.0 1.5 0.5 6.0 8.0 2.0 1.0 2.0 2.0 1.0 1.0 2.0 2.0 1.0 2.0 7.0 5.0 0.5 1.5 1.0 0.5 1.5 1.0 1.0 1.5 0.5 0.5 1.5 1.5 0.5 2.0 2.0 1.0 2.0 2.0 1.0 13.0 12.0 2.0 2.0 1.0 2.0 2.0 0.5 1.5 1.5 2.5 0.5 1.5 1.0 1.0 1.5 0.5 3.0 2.0 1.5 0.5 2.0 2.0 1.0 3.0 5.0 2.0 1.0 1.0 2.0 3.0 1.0 1.0 2.0 2.0 5.0 5.5 1.5 1.0 10.0 10.5 1.5 14.0 15.0 16.0")) :X 0.395999999999999D0 :Y 1.1280000858306876D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 0.1 :VALUE-STRING "0.1")) :X 0.6839999999999993D0 :Y 0.9319996833801265D0 :W 0.3399999809265135D0 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*) :OPEN-STATE-W 0.3399999809265135D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "decimals" :CURVAL 2 :VALUE-STRING "2")) :X 0.8039999999999998D0 :Y 0.7279996833801263D0 :W 0.26 :H 0.17359999 :BOX-STRING "g-round" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:G-ROUND) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-OUTPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-BOX) :R 0.9 :G 0.9 :B 0.9 :BOX-STRING "out" :CONNECTION NIL)) :X 0.3679999999999999D0 :Y 0.19200000000000017D0 :W 0.12 :H 0.12 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "1")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-OUTPUT) :OPEN-STATE-W 0.2000000014901162D0 :OPEN-STATE-H 0.01) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-OUTPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-BOX) :R 0.9 :G 0.9 :B 0.9 :BOX-STRING "out" :CONNECTION NIL)) :X 0.912000001490116D0 :Y 0.19200000000000017D0 :W 0.12 :H 0.12 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "2")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-OUTPUT) :OPEN-STATE-W 0.13200000149011615D0 :OPEN-STATE-H 0.01 :ABSTRACTION-OUTPUT-NUM 2)) :X 150 :Y 150 :TRANSLX -0.003600219726562326D0 :TRANSLY -0.29599995613098146D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.024999994840473106D0 :DY -0.11040004523098401D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.09599999558553096D0 :DY -0.09140015797316958D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 1 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0))) :TITLE "rt-seq" :X 150 :Y 150 :WIDTH 309 :HEIGHT 263))) WIN) :BOX-DOCUMENTATION "") (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-BOX) :R 0.65 :G 0.65 :B 0.65 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "arg" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.4720003738403329D0 :Y 1.0999997863769533D0 :W 0.26 :H 0.01 :BOX-STRING "mid_chnls" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.01 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-OUTPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-BOX) :R 0.9 :G 0.9 :B 0.9 :BOX-STRING "out" :CONNECTION NIL)) :X 0.20800000000000019D0 :Y 0.471999996185303D0 :W 0.12 :H 0.12 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "1")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-OUTPUT) :OPEN-STATE-W 0.1 :OPEN-STATE-H 0.01) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-OUTPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-BOX) :R 0.9 :G 0.9 :B 0.9 :BOX-STRING "out" :CONNECTION NIL)) :X 0.6880000014901162D0 :Y 0.471999996185303D0 :W 0.12 :H 0.12 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "2")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-OUTPUT) :OPEN-STATE-W 0.1 :OPEN-STATE-H 0.08199999977648265D0 :ABSTRACTION-OUTPUT-NUM 2) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-INPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :X 0.12400000000000011D0 :Y 1.2719999961853024D0 :W 0.1 :H 0.02 :BOX-STRING "1" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-INPUT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 1 :VALUE-STRING "1")) :X 0.022175606537812698D0 :Y 1.1070028710142306D0 :W 0.2759999809265139D0 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/) :OPEN-STATE-W 0.2759999809265139D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL (LIST 1 2 3 4) :VALUE-STRING "( 1 2 3 4)")) :X 0.11199999999999966D0 :Y 0.8519999332427974D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL 5 :VALUE-STRING "5")) :X 0.7360000014901162D0 :Y 0.8519999332427974D0 :W 0.4759999809265141D0 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT) :OPEN-STATE-W 0.4759999809265141D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.031999999999999584D0 :Y 0.6319999332427972D0 :W 0.26 :H 0.01 :BOX-STRING "flat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE FLAT) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.01) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.5400000014901156D0 :Y 0.6319999332427972D0 :W 0.26 :H 0.01 :BOX-STRING "flat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE FLAT) :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.01)) :X 150 :Y 150 :TRANSLY -0.31200047326087793D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.17499999558553103D0 :DY -0.06789999781176448D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2219999955855314D0 :DY -0.06989999781176448D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.2829122018906207D0 :DY -0.09290146712588943D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.029087798854437575D0 :DY -0.09290146712588943D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0040000020302835D0 :DY -0.07189996645227037D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.018000002030283513D0 :DY -0.0858999671973284D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.36491219745752535D0 :DY -0.1758985617942843D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0))) :TITLE "mid_chnls" :X 150 :Y 150 :WIDTH 340 :HEIGHT 280))) WIN) :BOX-DOCUMENTATION "")) :X 5 :Y 5 :TRANSLX -0.0044003906249998615D0 :TRANSLY 0.8479997212886817D0 :HITS 1 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 1 :PWBOX2 0 :INPUT-BOX 4 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.5711668584980072D0 :DY -0.22360011425614346D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 3 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.5278335255123676D0 :DY -0.18680011716485012D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.32000018895044957D0 :DY -0.3799000062979757D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 1 :PWBOX2 0 :INPUT-BOX 2 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2411667650379241D0 :DY -0.2125001197755334D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 1 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.19783343205228454D0 :DY -0.17570011895894977D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.03600000333413478D0 :DY -0.6314001213088629D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.227999996665865D0 :DY -0.12389999018236997D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0) :CX1 1.1932500014901164D0 :CY1 -0.29720045256614647D0 :CX2 0.09500000149011667D0 :CY2 -0.6528004781901826D0) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 1 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 1 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :R 0.33751747 :G 0.13681227 :B 1.0 :PWBOX1 0 :OUT-BOX 1 :PWBOX2 2 :INPUT-BOX 3 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 2 :PWBOX2 2 :INPUT-BOX 5 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 3 :PWBOX2 2 :INPUT-BOX 7 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :LINE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 619 :HEIGHT 755))) (WINDOW-SELECT WIN) WIN) | 40,191 | Common Lisp | .l | 4 | 10,047 | 40,036 | 0.738031 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 9dbcf882fdac906903185d5b4b881f383374c0ef4bdf8c8823044eb2f3db6d72 | 35,177 | [
-1
] |
35,178 | zeitnetz.pwgl | bornhoeft_ab-lisp/tutorial/TODO/zeitnetz.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "arg" :VALUE-STRING "0" :CONNECTION NIL)) :X 2.0274191331812235D0 :Y 0.8649163208826287D0 :W 0.2766094303585147D0 :H 0.11360944275628082D0 :BOX-STRING "dur2grtm" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.48D0 :Y 1.124D0 :W 0.325 :H 0.1 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.7299999963045125D0 :Y 0.707999988079071D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-INPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :X 0.41200000000000037D0 :Y 1.2679999999999998D0 :W 0.1 :H 0.02 :BOX-STRING "1" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-INPUT) :USER-STRING "dynamics") (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-OUTPUT-BOX) :R 0.7 :G 0.7 :B 0.7 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-BOX) :R 0.9 :G 0.9 :B 0.9 :BOX-STRING "out" :CONNECTION NIL)) :X 0.944D0 :Y -0.05599999999999916D0 :W 0.12 :H 0.12 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "1")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ABSTRACTION-OUTPUT) :USER-STRING "grtm" :OPEN-STATE-W 0.11200000149011613D0 :OPEN-STATE-H 0.08799999955296523D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "n" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.1400000000000006D0 :Y 0.8680000000000003D0 :W 0.26 :H 0.1 :BOX-STRING "abs" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE ABS)) (MAKE-INSTANCE (QUOTE PW-IF) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "test" :CURVAL (QUOTE IDENTITY) :VALUE-STRING "identity" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch1" :VALUE-STRING "0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch2" :CURVAL 100 :VALUE-STRING "100")) :X 0.44400000000000084D0 :Y 0.5679999694824218D0 :W 0.26 :H 0.24 :BOX-STRING "pwgl-if" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-IF)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "x" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.2960000000000007D0 :Y 0.7879999694824216D0 :W 0.26 :H 0.1 :BOX-STRING "minusp" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE MINUSP)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.14199999779462846D0 :Y 0.2399999865889546D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.012D0 :Y 0.45999996948242217D0 :W 0.26 :H 0.1 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list1" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.7959999999999998D0 :Y 0.18399996948242192D0 :W 0.26 :H 0.17359999 :BOX-STRING "append" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE APPEND) :CURRENT-EXTENSION-PATTERN-INDEX* 1)) :X 150 :Y 150 :TRANSLY 0.283999953508377D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.12799999796971662D0 :DY -0.05059998913109265D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0039999986588955D0 :Y -0.049600017398595764D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.20399999448284523D0 :DY -0.11620000295341004D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7609999998509882D0 :Y 0.06499998677521912D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.06800000203028312D0 :DY -0.07339999730885039D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7759999985843895D0 :Y 0.29999996933341056D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.02400000626221277D0 :DY -0.15540000753849737D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9919999985843897D0 :Y 0.5479999879300594D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.05299999209865902D0 :DY -0.06339999311417355D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6819999801367525D0 :Y 0.2879999757409095D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1247500015236438D0 :DY -0.2954000049456955D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.12199999637901815D0 :Y 0.9639999998509885D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.029999997969716974D0 :DY -0.07679999832808959D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.4239999985843905D0 :Y 0.6479999688863751D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1917500026263299D0 :DY -0.001400013498962016D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.2759999985843904D0 :Y 0.9639999998509885D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.017000008646398612D0 :DY -0.03740000420063749D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.2699999786466365D0 :Y 0.7279999994039539D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.03024999737367029D0 :DY -0.09139999824017275D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1199999985843903D0 :Y 0.9639999998509885D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.06999999927356826D0 :DY -0.12539999920874823D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.45999999858438967D0 :Y 1.0980000019371508D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7099999948889022D0 :Y 0.9639999998509885D0 :DX 0.0 :DY 0.0))) :TITLE "dur2grtm" :X 150 :Y 150 :WIDTH 380 :HEIGHT 436))) WIN) :BOX-DOCUMENTATION "") (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.5781284305468897D0 :Y 1.3090926130696368D0 :W 0.5366094208217715D0 :H 0.11660944138537399D0 :BOX-STRING "g-" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G-)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 0.25 :VALUE-STRING "0.25")) :X 1.7387304881173798D0 :Y 1.5495220900919083D0 :W 0.2766094303585147D0 :H 0.11660944138537399D0 :BOX-STRING "num-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUM-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL 0.25 :VALUE-STRING "0.25" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 2.2794303100310503D0 :Y 1.2653258973183732D0 :W 0.2766094303585147D0 :H 0.19020942811738006D0 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :R 0.5 :G 0.0 :B 0.5 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.5068323947056746D0 :Y 1.0706472761703428D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :R 0.5 :G 0.0 :B 0.5 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 1.3754138871340809D0 :Y 1.8447697787988662D0 :W 0.325 :H 0.099999994 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM)) (MAKE-INSTANCE (QUOTE PWGL-ENP-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE ENP-CONSTRUCTOR-FUNCTION) :CURVAL 1 :MINVAL 0 :MAXVAL 6 :MENU-LIST :ENP-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":part") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "score-notation" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.9614118181451193D0 :Y 0.38521894059130335D0 :W 0.8166094518161868D0 :H 0.11660944138537399D0 :BOX-STRING "enp-part-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 14 :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-PART-CONSTRUCTOR)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "begin" :CURVAL 10 :MINVAL 0 :VALUE-STRING "10") (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "end" :CURVAL 1.0 :MINVAL 0 :VALUE-STRING "1.0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 20 :VALUE-STRING "20" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curves" :CURVAL 1 :VALUE-STRING "1" :CONNECTION NIL)) :X 0.7019174595526097D0 :Y 1.594224821247374D0 :W 0.52 :H 0.16 :BOX-STRING "interpolation" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2) :ORIG-GROUPING-LIST (LIST 2 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE INTERPOLATION)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "type" :MINVAL 0 :MAXVAL 7 :MENU-LIST :ENP-OBJECT-COMPOSER-LIST :MENU-LIST-STRING "score") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "object/s" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.6515479112185592D0 :Y -0.03824465583966985D0 :W 0.52 :H 0.1 :BOX-STRING "enp-object-composer" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-OBJECT-COMPOSER)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.6896823959441388D0 :Y 0.8167865925297317D0 :W 0.26 :H 0.1 :BOX-STRING "flat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE FLAT)) (MAKE-INSTANCE (QUOTE SCORE-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-SCORE-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE ENP-APPLICATION-WINDOW) :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :Y 100.0 :DURATION 100.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 100.0 :WIDTH 82.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 0.25 :STEM-X 8.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 0.25 :DURATION 0.75 :STEM-X 8.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :STEM-X 11.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :STEM-X 15.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :STEM-X 19.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 27.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 27.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 31.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :STEM-X 35.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :STEM-X 39.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 23.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 8.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 11.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 2 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 66.0 :START-TIME 12.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 12.0 :STEM-X 66.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 13.0 :DURATION 0.25 :STEM-X 70.765 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 13.25 :DURATION 0.75 :STEM-X 71.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 14.0 :STEM-X 74.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 15.0 :STEM-X 78.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 3 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 62.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 16.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 16.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 18.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 19.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 4 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 20.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 21.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 22.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 23.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 5 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 24.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 26.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 27.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 6 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 28.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 28.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 30.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 31.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 7 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 32.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 32.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 33.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 34.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 34.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 35.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 8 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 36.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 36.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 37.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 38.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 39.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 9 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 40.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 41.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 43.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 10 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 44.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 44.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 44.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 45.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 46.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 11 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 48.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 49.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 50.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 51.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 12 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 52.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 55.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 13 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 56.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 56.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 57.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 58.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 59.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 14 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 60.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 61.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 62.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 63.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 15 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 64.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 64.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 67.0 :DURATION 0.25 :STEM-X 59.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 67.25 :DURATION 0.75 :STEM-X 59.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 16 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 68.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 68.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 69.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 70.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 71.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 17 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 72.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 72.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.0 :DURATION 0.25 :STEM-X 50.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.25 :DURATION 0.25 :STEM-X 52.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.5 :DURATION 0.5 :STEM-X 52.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 75.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 18 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 76.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 76.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 79.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 19 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 80.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 81.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.0 :DURATION 0.5 :STEM-X 58.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.5 :DURATION 0.25 :STEM-X 61.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.75 :DURATION 0.25 :STEM-X 61.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 20 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 84.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 85.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 87.0 :DURATION 0.75 :STEM-X 58.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 87.75 :DURATION 0.25 :STEM-X 62.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 21 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 88.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 88.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 90.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.0 :DURATION 0.25 :STEM-X 58.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.25 :DURATION 0.25 :STEM-X 60.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.5 :DURATION 0.5 :STEM-X 60.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 22 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 92.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 93.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.0 :DURATION 0.5 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.5 :DURATION 0.25 :STEM-X 57.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.75 :DURATION 0.25 :STEM-X 57.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 23 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 96.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.0 :DURATION 0.75 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.75 :DURATION 0.25 :STEM-X 50.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 24 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)))))) (MAKE-INSTANCE (QUOTE PART) :Y -5.625 :DURATION 100.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 100.0 :WIDTH 62.5 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 0.25 :STEM-X 8.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 0.25 :DURATION 0.75 :STEM-X 8.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :STEM-X 11.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :STEM-X 15.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :STEM-X 19.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 27.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 27.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 31.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :STEM-X 35.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :STEM-X 39.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 23.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 8.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.0 :DURATION 0.5 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.5 :DURATION 0.25 :STEM-X 57.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.75 :DURATION 0.25 :STEM-X 57.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 11.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 2 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 12.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 12.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 13.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 14.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 15.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 3 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 16.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 16.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 18.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 19.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 4 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 20.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.0 :DURATION 0.25 :STEM-X 46.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.25 :DURATION 0.25 :STEM-X 48.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.5 :DURATION 0.5 :STEM-X 48.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 21.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 22.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 23.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 5 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 24.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 26.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 27.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 6 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 28.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 28.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.0 :DURATION 0.5 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.5 :DURATION 0.25 :STEM-X 53.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.75 :DURATION 0.25 :STEM-X 53.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 30.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 31.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 7 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 32.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 32.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 33.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 34.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 35.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 8 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 36.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 36.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 37.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 38.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 38.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 39.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 9 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 40.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 41.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 43.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 10 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 44.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 44.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 45.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 46.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 46.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 11 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 48.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 49.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 50.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 51.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 12 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 52.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.0 :DURATION 0.25 :STEM-X 50.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.25 :DURATION 0.25 :STEM-X 52.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.5 :DURATION 0.5 :STEM-X 52.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 55.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 13 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 56.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 56.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 57.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 58.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 59.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 14 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 60.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.0 :DURATION 0.25 :STEM-X 46.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.25 :DURATION 0.25 :STEM-X 48.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.5 :DURATION 0.5 :STEM-X 48.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 61.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 62.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 63.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 15 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 64.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 64.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.0 :DURATION 0.5 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.5 :DURATION 0.25 :STEM-X 57.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.75 :DURATION 0.25 :STEM-X 57.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 67.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 16 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 68.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 68.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 69.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 70.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 71.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 17 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 72.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 72.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 72.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 75.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 18 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 76.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 76.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.0 :DURATION 0.25 :STEM-X 50.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.25 :DURATION 0.25 :STEM-X 52.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.5 :DURATION 0.5 :STEM-X 52.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 79.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 19 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 80.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 81.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 20 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 84.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 85.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 87.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 21 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 88.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 88.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.0 :DURATION 0.75 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.75 :DURATION 0.25 :STEM-X 54.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 90.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 22 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 92.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.0 :DURATION 0.75 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.75 :DURATION 0.25 :STEM-X 50.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 93.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.0 :DURATION 0.25 :STEM-X 58.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.25 :DURATION 0.25 :STEM-X 60.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.5 :DURATION 0.5 :STEM-X 60.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 23 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 96.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.0 :DURATION 0.5 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.5 :DURATION 0.25 :STEM-X 53.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.75 :DURATION 0.25 :STEM-X 53.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.0 :DURATION 0.25 :STEM-X 59.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.25 :DURATION 0.75 :STEM-X 59.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 24 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)))))) (MAKE-INSTANCE (QUOTE PART) :Y -11.25 :DURATION 100.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 100.0 :WIDTH 62.5 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 0.25 :STEM-X 8.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 0.25 :DURATION 0.75 :STEM-X 8.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :STEM-X 11.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :STEM-X 15.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :STEM-X 19.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 27.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 27.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 31.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :STEM-X 35.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :STEM-X 39.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 23.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 8.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.0 :DURATION 0.75 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.75 :DURATION 0.25 :STEM-X 50.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 11.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 2 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 12.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 12.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 13.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 14.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 15.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 3 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 16.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 16.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.0 :DURATION 0.25 :STEM-X 50.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.25 :DURATION 0.25 :STEM-X 52.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.5 :DURATION 0.5 :STEM-X 52.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 18.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 19.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 4 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 20.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 21.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 22.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 23.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 5 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 24.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.0 :DURATION 0.25 :STEM-X 50.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.25 :DURATION 0.25 :STEM-X 52.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.5 :DURATION 0.5 :STEM-X 52.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 26.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 27.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 6 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 28.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 28.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 30.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 31.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 7 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 32.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 32.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 33.0 :DURATION 0.25 :STEM-X 51.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 33.25 :DURATION 0.75 :STEM-X 51.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 34.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 35.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 8 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 36.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 36.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 37.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 38.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 39.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 9 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 40.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 41.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 43.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 10 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 44.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 44.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 45.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 46.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.0 :DURATION 0.25 :STEM-X 58.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.25 :DURATION 0.25 :STEM-X 60.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.5 :DURATION 0.5 :STEM-X 60.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 11 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 48.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 49.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 50.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 51.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 12 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 52.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 55.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 13 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 56.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 56.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 57.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 58.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 59.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 14 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 60.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 61.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 62.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 63.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 15 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 64.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 64.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.0 :DURATION 0.75 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.75 :DURATION 0.25 :STEM-X 54.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 67.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 16 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 68.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 68.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 69.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 70.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 71.0 :DURATION 0.25 :STEM-X 59.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 71.25 :DURATION 0.75 :STEM-X 59.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 17 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 72.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 72.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 75.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 18 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 76.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 76.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 76.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 79.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 19 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 80.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.0 :DURATION 0.25 :STEM-X 46.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.25 :DURATION 0.25 :STEM-X 48.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.5 :DURATION 0.5 :STEM-X 48.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 81.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 20 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 84.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 85.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 87.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 21 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 88.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 88.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 88.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 90.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.0 :DURATION 0.25 :STEM-X 59.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.25 :DURATION 0.75 :STEM-X 59.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 22 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 92.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 93.0 :DURATION 0.75 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 93.75 :DURATION 0.25 :STEM-X 54.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 23 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 96.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.0 :DURATION 0.25 :STEM-X 47.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.25 :DURATION 0.75 :STEM-X 47.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.0 :DURATION 0.75 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.75 :DURATION 0.25 :STEM-X 54.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.0 :DURATION 0.25 :STEM-X 59.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.25 :DURATION 0.75 :STEM-X 59.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 24 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)))))) (MAKE-INSTANCE (QUOTE PART) :Y -16.875 :DURATION 100.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 100.0 :WIDTH 62.5 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 0.25 :STEM-X 8.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 0.25 :DURATION 0.75 :STEM-X 8.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :STEM-X 11.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :STEM-X 15.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :STEM-X 19.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 27.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 27.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 31.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :STEM-X 35.0 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :DURATION 0.5 :STEM-X 39.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.25 :STEM-X 41.765 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.75 :DURATION 0.25 :STEM-X 42.0 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 23.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 8.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 8.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 8.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 9.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 9.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 10.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 10.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 11.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 11.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 2 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 12.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 12.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 12.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 13.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 13.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 14.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 14.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 14.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 15.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 15.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 3 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 16.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 16.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 16.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 17.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 17.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 18.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 18.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 19.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 19.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 4 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 20.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 20.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 20.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 21.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 21.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 22.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 22.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 22.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 23.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 23.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 5 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 24.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 24.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 24.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 25.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 25.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 26.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 26.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 27.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 27.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 6 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 28.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 28.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 28.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.0 :DURATION 0.25 :STEM-X 51.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 29.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 29.25 :DURATION 0.75 :STEM-X 51.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 30.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 30.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 31.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 31.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 7 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 32.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 32.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 32.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 33.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 33.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 34.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 34.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 35.0 :DURATION 0.75 :STEM-X 58.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 35.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 35.75 :DURATION 0.25 :STEM-X 62.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 8 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 36.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 36.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 36.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 37.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 37.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 38.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 38.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 39.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 39.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 9 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 40.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 40.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 40.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 41.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 41.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.0 :DURATION 0.25 :STEM-X 54.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.25 :DURATION 0.25 :STEM-X 56.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 42.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 42.5 :DURATION 0.5 :STEM-X 56.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 43.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 43.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 10 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 44.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 44.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 44.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 45.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 45.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 46.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 46.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 47.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 47.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 11 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 48.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 48.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 48.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 49.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 49.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 50.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 50.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 51.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 51.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 12 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 52.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 52.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 52.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 53.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 53.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.0 :DURATION 0.25 :STEM-X 54.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.25 :DURATION 0.25 :STEM-X 56.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 54.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 54.5 :DURATION 0.5 :STEM-X 56.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 55.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 55.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 13 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 56.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 56.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 56.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 57.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 57.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 58.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 58.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 59.0 :DURATION 0.75 :STEM-X 58.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 59.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 59.75 :DURATION 0.25 :STEM-X 62.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 14 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 60.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 60.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 60.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 61.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 61.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 62.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 62.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 63.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 63.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 15 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 64.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 64.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 64.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.0 :DURATION 0.25 :STEM-X 51.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 65.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 65.25 :DURATION 0.75 :STEM-X 51.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 66.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 66.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 67.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 67.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 16 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 68.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 68.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 68.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 69.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 69.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 70.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 70.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 70.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 71.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 71.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 17 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 72.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 72.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 72.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 73.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 73.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.0 :DURATION 0.5 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.5 :DURATION 0.25 :STEM-X 57.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 74.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 74.75 :DURATION 0.25 :STEM-X 57.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 75.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 75.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 18 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 76.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 76.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 76.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 77.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 77.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 78.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 78.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 79.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 79.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 19 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 80.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 80.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 80.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 81.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 81.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.0 :DURATION 0.75 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 82.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 82.75 :DURATION 0.25 :STEM-X 58.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 83.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 83.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 20 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 84.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 84.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 84.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 85.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 85.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.0 :DURATION 0.25 :STEM-X 54.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.25 :DURATION 0.25 :STEM-X 56.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 86.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 86.5 :DURATION 0.5 :STEM-X 56.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 87.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 87.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 21 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 88.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 88.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 88.0 :STEM-X 46.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.0 :DURATION 0.5 :STEM-X 50.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.5 :DURATION 0.25 :STEM-X 53.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 89.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 89.75 :DURATION 0.25 :STEM-X 53.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 90.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 90.0 :STEM-X 54.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 91.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 91.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 22 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 92.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.0 :DURATION 0.25 :STEM-X 46.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.25 :DURATION 0.25 :STEM-X 48.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 92.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 92.5 :DURATION 0.5 :STEM-X 48.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 93.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 93.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.0 :DURATION 0.5 :STEM-X 54.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.5 :DURATION 0.25 :STEM-X 57.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 94.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 94.75 :DURATION 0.25 :STEM-X 57.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 95.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 95.0 :STEM-X 58.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 23 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 46.5 :START-TIME 96.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.0 :DURATION 0.5 :STEM-X 46.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.5 :DURATION 0.25 :STEM-X 49.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 96.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 96.75 :DURATION 0.25 :STEM-X 49.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 97.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 97.0 :STEM-X 50.5 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.0 :DURATION 0.25 :STEM-X 55.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 98.0 :UNIT-LENGTH -3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 98.25 :DURATION 0.75 :STEM-X 55.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.75 :TOTAL-DUR 0.75))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.0 :DURATION 0.25 :STEM-X 58.5 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.25 :DURATION 0.25 :STEM-X 60.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 99.0 :UNIT-LENGTH -2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 99.5 :DURATION 0.5 :STEM-X 60.5 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 24 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 4 :X 43.0))))))) :X 150 :Y 150 :TITLE "Score-Editor2" :X 150 :Y 150 :WIDTH 594 :HEIGHT 841))) WIN) :CONNECTION NIL)) :X 1.8359062542363365D0 :Y 0.09962588158860592D0 :W 0.7 :H 0.32 :BOX-STRING "Score-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "score") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "rtms/times")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SCORE-EDITOR)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "grtms" :CURVAL (LIST (LIST 1 1 1 1) 100 100 100 100) :VALUE-STRING "((1 1 1 1) 100 100 100 100)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enp-obj" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "barsls" :CURVAL (LIST 4 4) :VALUE-STRING "(4 4)") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "scope" :CURVAL (LIST 1 (LIST 1 2 4) NIL) :VALUE-STRING "(1 (1 2 4)())") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "barscope" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "tempi" :CURVAL 60 :VALUE-STRING "60")) :X 2.4247089531112356D0 :Y 0.9240248916161953D0 :W 0.75 :H 0.46799997 :BOX-STRING "gquantify" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1 1 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 6 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:GQUANTIFY) :CURRENT-EXTENSION-PATTERN-INDEX* 5) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :R 1.0 :G 0.5 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 16 18 20 22) :VALUE-STRING "(16 18 20 22)") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0.7 0.9 1.1 1.3) :VALUE-STRING "(0.7 0.9 1.1 1.3)")) :X 0.4493133111752119D0 :Y 1.9506168833103428D0 :W 0.4642804718040989D0 :H 0.20055751486055734D0 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :X-PROPORTIONS (LIST (LIST 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM) :OPEN-STATE-W 0.4642804718040989D0 :OPEN-STATE-H 0.1134787579796348D0 :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :R 1.0 :G 0.5 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.6313133074797239D0 :Y 0.2578120341391301D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sum" :CURVAL 100 :VALUE-STRING "100")) :X 0.7683105480938264D0 :Y 1.294650734153758D0 :W 0.52 :H 0.1 :BOX-STRING "g-scaling/sum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:G-SCALING/SUM))) :X 5 :Y 5 :SCALEFX 0.4451449266140638D0 :SCALEFY 0.4451449266140638D0 :TRANSLX -0.33249731897951973D0 :TRANSLY 0.2823638276473093D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 1 :PWBOX2 7 :INPUT-BOX 3 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.27697817720638185D0 :DY -0.1115385153324886D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.256917440628135D0 :Y 1.675059370126166D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.08435826466933633D0 :DY -0.1115385153324886D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.666917459403598D0 :Y 1.675059370126166D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3324087755925207D0 :DY -0.0834708716659398D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3554138857184706D0 :Y 1.1546507335577117D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 14 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.20146856969925153D0 :DY 0.054093439404849675D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7483105466782161D0 :Y 1.3742248261647572D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.7539077988982161D0 :DY -0.04154164195213861D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1915478935606832D0 :Y 0.09781203399011851D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.1414309879961042D0 :DY -0.09043897338114515D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.171313289821848D0 :Y 0.20860950054703387D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6113133060641136D0 :Y 1.6900593697908899D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.23273624212796285D0 :DY -0.06618764906985597D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.7980212713769164D0 :Y 0.3960249280048309D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.03949898526767126D0 :DY -0.088539609768291D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.4047089516956253D0 :Y 0.7113068790204176D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.7297945199445517D0 :DY 0.43346379035023386D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.8159062528207262D0 :Y -0.1782446564357163D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.3457680673580876D0 :DY -0.7344337487094725D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.007419131765613D0 :Y 0.6767865919336853D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.038153959950398386D0 :DY -0.3311368432659577D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.6696823945285284D0 :Y 0.9106472760213311D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.8067703673109397D0 :DY -0.2849733692809618D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.0468323770477986D0 :Y 1.0151164705420977D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.8724924733260533D0 :DY -0.4310180006561882D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.1347378527842716D0 :Y 1.6847697861004352D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.337999997969717D0 :DY -0.129399998240173D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5581284291312794D0 :Y 1.392912649600604D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.21199999796971714D0 :DY -0.0873999973088504D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.25943030861544D0 :Y 1.392912649600604D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.19700000441446863D0 :DY 0.09380000559985646D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.2444303098820386D0 :Y 1.1374831729136086D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.4868323932900643D0 :Y 1.6847697861004352D0 :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 190,607 | Common Lisp | .l | 4 | 47,651 | 190,452 | 0.718705 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | fa3b6f684d235781476c8cde5875590b53b43d574e74e7ae8511848136f0ecfb | 35,178 | [
-1
] |
35,179 | parallell-processes.pwgl | bornhoeft_ab-lisp/tutorial/TODO/parallell-processes.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PMC-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "search-space" :CURVAL (LIST (QUOTE 4*) (LIST (LIST (QUOTE |0_3|)))) :VALUE-STRING "(4* ((0_3)))") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "term-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "heur-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "rnd?" :MINVAL 0 :MAXVAL 1 :ACTIVE-INPUT? NIL :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sol-mode" :CURVAL 1 :MINVAL 1 :VALUE-STRING "1" :ACTIVE-INPUT? NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "prep-fns" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "procs?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "p-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "r-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "schedules" :CURVAL NIL :VALUE-STRING "()")) :X 1.7076908451177555D0 :Y 1.5664893031245864D0 :W 0.69 :H 0.3256 :BOX-STRING "Multi-PMC" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 3 3 4) :ORIG-GROUPING-LIST (LIST 1 3) :EXTENSION-PATTERN (LIST 3 4) :EXTENSION-LIMIT 11 :Y-PROPORTIONS (LIST 1 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE MULTI-PMC) :CURRENT-EXTENSION-PATTERN-INDEX 1 :ALL-SOLS (LIST (LIST (LIST 0 3 2 0)) (LIST (LIST 0 2 2 2))) :RESULT-SLIDERS (LIST (MAKE-INSTANCE (QUOTE PWGL-PMC-SLIDER) :R 0.9 :G 0.9 :B 0.9 :X 1.7076908451177555D0 :Y 1.160889291775862D0 :W 0.04 :H 0.04 :BOX-STRING "2" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-PMC-OUTPUT))) :PW-FUNCTION (QUOTE SLIDER) :CURVAL 4 :MINVAL 0 :MAXVAL 4 :NUMBER-OF-DECIMALS 0 :FORMAT-STRING "~1,2f" :VALUE-STRING "4" :PMC-RESULT (LIST (LIST 0 3 2 0))))) (MAKE-INSTANCE (QUOTE PMC-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "search-space" :CURVAL (LIST (QUOTE 4*) (LIST (LIST (QUOTE |0_3|)))) :VALUE-STRING "(4* ((0_3)))") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "term-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "heur-rules" :CURVAL "()" :VALUE-STRING "()")) :X 2.476715996065814D0 :Y 1.5460490491375765D0 :Z -0.1 :W 0.69 :H 0.17600002 :BOX-STRING "Multi-PMC" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 3) :ORIG-GROUPING-LIST (LIST 1 3) :EXTENSION-PATTERN (LIST 3 4) :EXTENSION-LIMIT 11 :Y-PROPORTIONS (LIST 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE MULTI-PMC) :CURRENT-EXTENSION-PATTERN-INDEX* 2 :STORED-EXTEND-INPUTS-LIST (LIST (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "rnd?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sol-mode" :CURVAL 1 :MINVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "prep-fns" :CURVAL "()" :VALUE-STRING "()")) (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "procs?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "p-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "r-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "schedules" :CURVAL "()" :VALUE-STRING "()")) (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "rnd?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sol-mode" :CURVAL 1 :MINVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "prep-fns" :CURVAL "()" :VALUE-STRING "()")) (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "procs?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "p-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "r-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "schedules" :CURVAL "()" :VALUE-STRING "()"))) :ALL-SOLS (LIST (LIST 0 0 3 1)))) :X 5 :Y 5 :SCALEFX 1.106086973837052D0 :SCALEFY 1.106086973837052D0 :TRANSLX -1.5588006887351463D0 :TRANSLY -1.047839416086095D0 :SNAPSHOTS (LIST (MAKE-INSTANCE (QUOTE PWGL-SNAPSHOT) :NAME "1" :DATA (LIST 0.572064206917489D0 0.572064206917489D0 -2.510340379860125D0 -0.16477763919217847D0))) :X 521 :Y 23 :WIDTH 1038 :HEIGHT 376))) (WINDOW-SELECT WIN) WIN) | 5,538 | Common Lisp | .l | 4 | 1,383.75 | 5,383 | 0.704607 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 42d4236cb4e436c2a279ca6d37f694ffb0b31aafe8e795801040ebdd432af695 | 35,179 | [
-1
] |
35,180 | tendency.pwgl | bornhoeft_ab-lisp/tutorial/TODO/tendency.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(((0.0 1.25 2.5 3.75 5.0 6.25 7.5 8.75 10.0 11.25 12.5 13.75 15.0 16.25 17.5 18.75 20.0 21.25 22.5 23.75 25.0 26.25 27.5 28.75 30.0) (72 70 70 74 76 76 76 77 76 76 79 72 70 80 78 71 76 73 71 71 76 77 72 77 71)) ((0.0 0.9677419 1.9354838 2.9032257 3.8709677 4.8387094 5.8064513 6.7741933 7.7419353 8.709677 9.677419 10.645161 11.612903 12.580645 13.548387 14.516129 15.4838705 16.451613 17.419354 18.387097 19.354838 20.32258 21.290322 22.258065 23.225806 24.193549 25.16129 26.129033 27.096774 28.064517 29.032258 30.0) (43 46 50 47 49 48 44 42 42 48 47 43 50 41 45 49 43 46 44 47 49 44 48 50 44 50 45 41 49 45 45 44)))" :CONNECTION NIL)) :X 2.212000001490115D0 :Y 1.4760001453757284D0 :W 0.5600000119209292D0 :H 0.1800000014901162D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.5600000119209292D0 :OPEN-STATE-H 0.1800000014901162D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "begin" :VALUE-STRING "0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "end" :CURVAL 30.0 :VALUE-STRING "30.0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 25 :VALUE-STRING "25" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curves" :CURVAL 1 :VALUE-STRING "1")) :X 0.1759999999999997D0 :Y 1.6160001468658454D0 :W 0.52 :H 0.16 :BOX-STRING "interpolation" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2) :ORIG-GROUPING-LIST (LIST 2 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:INTERPOLATION)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 25 :VALUE-STRING "25")) :X 0.496D0 :Y 1.9160001468658448D0 :W 0.26 :H 0.1 :BOX-STRING "num-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUM-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "low" :CURVAL 70 :VALUE-STRING "70") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "high" :CURVAL 80 :VALUE-STRING "80")) :X 1.2360000000000002D0 :Y 1.7760001468658438D0 :W 0.52 :H 0.1 :BOX-STRING "g-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G-RANDOM)) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.956D0 :Y 1.5280001468658449D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.7960000000000003D0 :Y 1.172000146865845D0 :W 0.26 :H 0.17359999 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0.0 72) (1.25 70) (2.5 70) (3.75 74) (5.0 76) (6.25 76) (7.5 76) (8.75 77) (10.0 76) (11.25 76) (12.5 79) (13.75 72) (15.0 70) (16.25 80) (17.5 78) (18.75 71) (20.0 76) (21.25 73) (22.5 71) (23.75 71) (25.0 76) (26.25 77) (27.5 72) (28.75 77) (30.0 71)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0.0 43) (0.9677419 46) (1.9354838 50) (2.9032257 47) (3.8709677 49) (4.8387094 48) (5.8064513 44) (6.7741933 42) (7.7419353 42) (8.709677 48) (9.677419 47) (10.645161 43) (11.612903 50) (12.580645 41) (13.548387 45) (14.516129 49) (15.4838705 43) (16.451613 46) (17.419354 44) (18.387097 47) (19.354838 49) (20.32258 44) (21.290322 48) (22.258065 50) (23.225806 44) (24.193549 50) (25.16129 45) (26.129033 41) (27.096774 49) (28.064517 45) (29.032258 45) (30.0 44))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.9 :GLORTHOX2 30.9 :GLORTHOY1 39.83 :GLORTHOY2 81.17)) :X 325 :Y 210 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 761 :Y 138 :WIDTH 656 :HEIGHT 414))) WIN) :CONNECTION NIL)) :X 3.1440000014901157D0 :Y 1.0120001453757284D0 :W 0.5 :H 0.5 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR)) (MAKE-INSTANCE (QUOTE PWGL-2D-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE 2D-CONSTRUCTOR-FUNCTION) :MINVAL 0 :MAXVAL 5 :MENU-LIST :2D-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":bpf") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "xs/l" :CURVAL (LIST (LIST 0 1 2) (LIST 0 1 0)) :VALUE-STRING "((0 1 2) (0 1 0))" :CONNECTION NIL)) :X 2.5000000014901165D0 :Y 0.9880001453757292D0 :W 0.45 :H 0.166 :BOX-STRING "2d-bpf-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-BPF-CONSTRUCTOR)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "begin" :VALUE-STRING "0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "end" :CURVAL 30.0 :VALUE-STRING "30.0") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 25 :VALUE-STRING "25" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curves" :CURVAL 1 :VALUE-STRING "1")) :X 0.0760000014901161D0 :Y 0.6040001453757293D0 :W 0.52 :H 0.16 :BOX-STRING "interpolation" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2) :ORIG-GROUPING-LIST (LIST 2 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:INTERPOLATION)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 32 :VALUE-STRING "32")) :X 0.3960000014901164D0 :Y 0.9040001453757287D0 :W 0.26 :H 0.1 :BOX-STRING "num-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUM-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "low" :CURVAL 41 :VALUE-STRING "41") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "high" :CURVAL 50 :VALUE-STRING "50")) :X 1.1360000014901166D0 :Y 0.7640001453757277D0 :W 0.52 :H 0.1 :BOX-STRING "g-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G-RANDOM)) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.8560000014901164D0 :Y 0.5160001453757288D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.8000000014901168D0 :Y 0.4400001453757292D0 :W 0.26 :H 0.17359999 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 2.172000001490116D0 :Y 0.7640001453757286D0 :Z -0.1 :W 0.26 :H 0.17359999 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1)) :X 5 :Y 5 :TRANSLY 0.10399978160858155D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.049999997969717436D0 :DY 0.40739999512583003D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.1920000000745046D0 :Y 0.5304001584947109D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.05800000203028288D0 :DY 0.22659999896585914D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.1370000013411046D0 :Y 0.19140015882998762D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.06000000277534112D0 :DY -0.10260000468790542D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.152000000074506D0 :Y 0.9384001599848273D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.4379999979697169D0 :DY -0.033099997475743104D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.041000001341104486D0 :Y 0.7490001451149584D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.0799999979697168D0 :DY -0.1493999982401728D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.836000000074506D0 :Y 0.7640001447796823D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.07500000441446897D0 :DY -0.09339999824017231D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3959999838322404D0 :Y 0.6240001447796812D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.11100000441446922D0 :DY -0.1573999998420479D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7800000000745065D0 :Y 0.3840001502931125D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2789999955855309D0 :DY -0.18019999440014356D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7650000013411052D0 :Y 0.3610001451149585D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.27650000262632957D0 :DY 0.011599996365606602D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.1240000000745054D0 :Y 0.7620001530349261D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2550000033341343D0 :DY -0.1913499964475629D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.465000001341105D0 :Y 1.241000145114958D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2789999955855309D0 :DY -0.18019999440014356D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7609999998509887D0 :Y 1.3730001466050746D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.11100000441446922D0 :DY -0.1573999998420479D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.77599999858439D0 :Y 1.3960001517832286D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.07500000441446897D0 :DY -0.09339999824017231D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.495999982342124D0 :Y 1.6360001462697973D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.0799999979697168D0 :DY -0.1493999982401728D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9359999985843897D0 :Y 1.7760001462697983D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.4379999979697169D0 :DY -0.033099997475743104D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.1409999998509881D0 :Y 1.7610001466050745D0 :DX 0.0 :DY 0.0))) :X 188 :Y 167 :WIDTH 963 :HEIGHT 558))) (WINDOW-SELECT WIN) WIN) | 18,621 | Common Lisp | .l | 4 | 4,654.5 | 18,466 | 0.744709 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 42dce76324720254a5570f95aec7bd9b9177eedb730cd37d4b2831a1483a57ae | 35,180 | [
-1
] |
35,181 | flag.pwgl | bornhoeft_ab-lisp/tutorial/TODO/flag.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 745 :Y 527 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(in-package :cl-user)
(defun flag (interval)
(let* ((g (first interval))
(f (second interval))
(i (abs (- f g))))
(case i
(4 (+ g 28))
(5 (+ g 24))
(7 (+ g 19))
(9 (+ g 28))
(12 (+ g 12))
(otherwise interval))))
;; (flag '(60 65))")) :X 1.0479999999999996D0 :Y 1.944D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-CHORD-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-CHORD-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE CHORD-EDITOR-WINDOW) :SPACING 0.3 :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :X 0.0 :Y 45.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH NIL :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 64)))) :PIXELS/SEC 3.0))) (MAKE-INSTANCE (QUOTE PART) :X 0.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH 9.5 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 65)))) :PIXELS/SEC 7.5000005))) (MAKE-INSTANCE (QUOTE PART) :X 0.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH 9.5 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 67)))) :PIXELS/SEC 7.5000005))) (MAKE-INSTANCE (QUOTE PART) :X 0.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH 9.5 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 69)))) :PIXELS/SEC 7.5000005))) (MAKE-INSTANCE (QUOTE PART) :X 0.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH 9.5 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 72)))) :PIXELS/SEC 7.5000005))) (MAKE-INSTANCE (QUOTE PART) :X 0.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 4.5 :WIDTH 9.5 :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :PLIST (LIST :TEMP-PITCHES NIL) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 70)))) :PIXELS/SEC 7.5000005)))) :EDIT-MODE NIL :SCALEFX 2.3 :SCALEFY 2.3 :TRANSLX 18.0 :TRANSLY -8.0 :X 221 :Y 58 :ROWS 2 :COLUMNS 3 :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :TITLE "Chord-Editor1" :X 221 :Y 58 :WIDTH 910 :HEIGHT 432))) WIN) :CONNECTION NIL)) :X 0.45599999999999996D0 :Y 2.012D0 :W 0.4 :H 0.5 :BOX-STRING "Chord-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "chord") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CHORD-EDITOR)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "interval" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.388D0 :Y 1.4719999999999996D0 :W 0.26 :H 0.1 :BOX-STRING "flag" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::FLAG)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(60 64)
(60 65)
(60 67)
(60 69)
(60 72)
(60 70)")) :X 0.14400000000000057D0 :Y 1.9360000000000004D0 :W 0.2440000119209289D0 :H 0.41200000149011596D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.2440000119209289D0 :OPEN-STATE-H 0.41200000149011596D0) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.9439999999999991D0 :Y 1.5800000000000006D0 :W 0.325 :H 0.1 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.13399999630451198D0 :Y 0.6479999880790714D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PW-IF) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "test" :CURVAL (QUOTE IDENTITY) :VALUE-STRING "identity" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch1" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch2" :CURVAL 1 :VALUE-STRING "1" :CONNECTION NIL)) :X 1.8119999999999985D0 :Y 0.8719999999999999D0 :W 0.26 :H 0.24 :BOX-STRING "pwgl-if" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-IF)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "x" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.988D0 :Y 1.2640000000000007D0 :W 0.26 :H 0.1 :BOX-STRING "numberp" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUMBERP)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.9079999999999995D0 :Y 1.096D0 :W 0.26 :H 0.1 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST)) (MAKE-INSTANCE (QUOTE PWGL-ENP-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE ENP-CONSTRUCTOR-FUNCTION) :CURVAL 5 :MINVAL 0 :MAXVAL 6 :MENU-LIST :ENP-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":chord") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "pitches" :CURVAL (LIST 60) :VALUE-STRING "(60)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-UPDATE-MENUBOX-SUBVIEW) :BOX-STRING "keyarg" :PWGL-ACTION-FUNCTION (QUOTE UPDATE-NEXT-SUBBOX) :CURVAL 5 :MINVAL 0 :MAXVAL 12 :MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-1 :MENU-LIST-STRING ":expressions" :UPDATE-MENU-LIST :ENP-CONSTRUCTOR-MENU-LIST-CHORD-2) (MAKE-INSTANCE (QUOTE PWGL-HIERARCHICAL-MENUBOX-SUBVIEW) :BOX-STRING "nil" :CURVAL 4 :MINVAL 0 :MAXVAL 8 :MENU-LIST (LIST (LIST ":analysis-group" ":score-expression") (LIST ":annotation-expression") (LIST ":accent" ":accent-grave" ":accent-grave-with-dot" ":bartok-pizzicato" ":natural-harmonics" ":slur" ":staccatissimo" ":staccato" ":tenuto") (LIST ":figured-bass") (LIST ":col-legno" ":martellato" ":pizz" ":punta-d-arco" ":ricoche" ":saltando" ":spiccato" ":sul-ponticello" ":sul-tasto") (LIST ":conductor-mark") (LIST ":crescendo" ":diminuendo" ":f" ":ff" ":fff" ":fp" ":fz" ":mf" ":mp" ":p" ":pp" ":ppp" ":sf" ":sff" ":sfz") (LIST ":trumpet-fingering") (LIST ":canvas-expression" ":image-expression") (LIST ":bpf" ":group") (LIST ":guitar-fret" ":harp-pedal" ":piano-pedal") (LIST ":lyrics") (LIST ":fermata" ":parenthesis" ":repetition-box") (LIST ":con-sord-") (LIST ":15ma" ":15mb" ":8ba" ":8va") (LIST ":arpeggio" ":trillo") (LIST ":breath-mark") (LIST ":tremolo16" ":tremolo32" ":tremolo64" ":tremolo8" ":tremoloz") (LIST ":analysis-text-group" ":beam-expression") (LIST ":pc-clock") (LIST ":string1" ":string2" ":string3" ":string4" ":string5" ":string6" ":string7" ":string8" ":string9") (LIST ":accelerando" ":ritardando" ":rubato") (LIST ":plain-text") (LIST ":cross-staff" ":glissando" ":portamento")) :MENU-LIST-STRING ":natural-harmonics" :CURVAL2 2 :MENU-TITLES (LIST "analysis" "annotations" "articulations" "baroque" "bowing" "conducting" "dynamics" "fingerings" "graphics" "groups" "instrumental" "lyrics" "misc" "mutes" "octavation" "ornaments" "phrasing" "repetitions" "schenker" "set-theory" "string-numbers" "tempo-marks" "text" "transitions") :MENU-TITLES-STRING "articulations" :MAXVAL2 23)) :X 0.7840000820159903D0 :Y 0.8520000762939439D0 :W 0.840000011920929D0 :H 0.16159998822212218D0 :BOX-STRING "enp-chord-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 24 :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-CHORD-CONSTRUCTOR) :OPEN-STATE-W 0.840000011920929D0 :OPEN-STATE-H 0.16159998822212218D0 :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "type" :CURVAL 2 :MINVAL 0 :MAXVAL 7 :MENU-LIST :ENP-OBJECT-COMPOSER-LIST :MENU-LIST-STRING "voice") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "object/s" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.27600000000000025D0 :Y 0.37600004577636703D0 :W 0.52 :H 0.1 :BOX-STRING "enp-object-composer" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-OBJECT-COMPOSER)) (MAKE-INSTANCE (QUOTE PWGL-ENP-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE ENP-CONSTRUCTOR-FUNCTION) :CURVAL 5 :MINVAL 0 :MAXVAL 6 :MENU-LIST :ENP-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":chord") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "pitches" :CURVAL (LIST 60 64) :VALUE-STRING "(60 64)" :CONNECTION NIL)) :X 1.3440000835061068D0 :Y 1.2600000748038278D0 :W 0.8 :H 0.099999994 :BOX-STRING "enp-chord-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 24 :BORDER 0.012) :PW-FUNCTION (QUOTE ENP-CHORD-CONSTRUCTOR)) (MAKE-INSTANCE (QUOTE SCORE-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-SCORE-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE ENP-APPLICATION-WINDOW) :PAGE-LAYOUT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE ENP-PAGE-LAYOUT-OBJECT) :PAGE-NUMBER :PAGE :MEASURES-PER-SYSTEM 2 :SYSTEMS-PER-PAGE 4) (MAKE-INSTANCE (QUOTE ENP-PAGE-LAYOUT-OBJECT) :PAGE-NUMBER :SCROLL :MEASURES-PER-SYSTEM 6)) :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :Y 100.0 :DURATION 6.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 6.0 :WIDTH 34.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :LOCAL-STEM-DOWN-P T :STEM-X 7.575 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :LOCAL-STEM-DOWN-P T :MIDI 88)) :EXPRESSIONS (EVAL-LIST (QUOTE ((QUOTE NATURAL-HARMONICS))))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 4.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 15.0 :START-TIME 1.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :LOCAL-STEM-DOWN-P T :STEM-X 15.075 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :LOCAL-STEM-DOWN-P T :MIDI 84)) :EXPRESSIONS (EVAL-LIST (QUOTE ((QUOTE NATURAL-HARMONICS))))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 11.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 22.5 :START-TIME 2.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :LOCAL-STEM-DOWN-P T :STEM-X 22.575 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :LOCAL-STEM-DOWN-P T :MIDI 79)) :EXPRESSIONS (EVAL-LIST (QUOTE ((QUOTE NATURAL-HARMONICS))))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 2 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 19.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 30.0 :START-TIME 3.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :LOCAL-STEM-DOWN-P T :STEM-X 30.075 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :LOCAL-STEM-DOWN-P T :MIDI 88)) :EXPRESSIONS (EVAL-LIST (QUOTE ((QUOTE NATURAL-HARMONICS))))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 3 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 26.5)) (MAKE-INSTANCE (QUOTE MEASURE) :X 37.5 :START-TIME 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :LOCAL-STEM-DOWN-P T :STEM-X 37.575 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :LOCAL-STEM-DOWN-P T :MIDI 72)) :EXPRESSIONS (EVAL-LIST (QUOTE ((QUOTE NATURAL-HARMONICS))))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 4 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 34.0)) (MAKE-INSTANCE (QUOTE MEASURE) :X 45.0 :START-TIME 5.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 45.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 70))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 5 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 1 :X 41.5))))))) :X 150 :Y 150 :TITLE "Score-Editor2" :X 667 :Y 333 :WIDTH 594 :HEIGHT 841))) WIN) :CONNECTION NIL :SCORE-DISPLAY-MODE :FOLLOW-SCORE)) :X 1.12D0 :Y 0.5040000457763672D0 :W 1.063999988079071D0 :H 0.34399999284744265D0 :BOX-STRING "Score-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "score") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "rtms/times")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SCORE-EDITOR) :OPEN-STATE-W 1.063999988079071D0 :OPEN-STATE-H 0.34399999284744265D0)) :X 5 :Y 5 :TRANSLY -0.060000239849090586D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.29100000441446894D0 :DY -0.1103999979421495D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0999999985843898D0 :Y 0.23600004518032058D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.21100004508718895D0 :DY -0.2620000414401287D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7619999992549405D0 :Y 1.070000082775949D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.9340000504516064D0 :DY -0.14939995990693622D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.164000096842646D0 :Y 1.331999999403953D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.12599999743327506D0 :DY -0.13939996939152488D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8159999823421242D0 :Y 0.48799998793005983D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.35899995565786935D0 :DY 0.06039995776116913D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7769999998509869D0 :Y 0.6154000897482024D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.4880000497065484D0 :DY -0.1413999591618782D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.6440000953525296D0 :Y 0.9359999998509885D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.18500000864639832D0 :DY -0.03740000762790441D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.673999978646636D0 :Y 0.5920000062584876D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.04000000203028309D0 :DY -0.12939999824017257D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8879999985843892D0 :Y 1.331999999403953D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2839999979697172D0 :DY -0.12079999832808985D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7919999985843882D0 :Y 1.1239999994039543D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.4220000020302832D0 :DY 0.10060000175982742D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9679999985843897D0 :Y 1.331999999403953D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.10975000262632984D0 :DY 0.16260000175982703D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3679999985843896D0 :Y 1.419999999850989D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 1 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.05366665935888881D0 :DY -0.14739999898523104D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9239999985843888D0 :Y 1.4520000013411046D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.11399999488890167D0 :Y 1.419999999850989D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.13000000333413486D0 :DY -0.2213999997302889D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.43599999858438965D0 :Y 1.483999999403954D0 :DX 0.0 :DY 0.0))) :X 0 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 25,424 | Common Lisp | .l | 21 | 1,207.52381 | 19,613 | 0.736477 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | a7196f4a6a698668c30a6a982ab074a27b1f338a03727c362274dbcea3e34a31 | 35,181 | [
-1
] |
35,182 | macros.pwgl | bornhoeft_ab-lisp/tutorial/TODO/macros.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.48189998 :G 0.3919 :B 0.3919 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL (QUOTE REDUCE) :VALUE-STRING "reduce") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :CURVAL (LIST (QUOTE FUNCTION) (QUOTE +)) :VALUE-STRING "#'+") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :CURVAL (LIST (QUOTE QUOTE) (LIST 1 2 3 4 5)) :VALUE-STRING "'(1 2 3 4 5)")) :X 1.4473286936596002D0 :Y 1.4484796829223634D0 :W 0.5315366353988646D0 :H 0.25519998240470887D0 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :OPEN-STATE-W 0.5315366353988646D0 :OPEN-STATE-H 0.25519998240470887D0 :CURRENT-EXTENSION-PATTERN-INDEX* 2) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL (LIST (QUOTE *) (QUOTE PI) 10) :VALUE-STRING "(* pi 10)" :CONNECTION NIL)) :X 1.0148014471530913D0 :Y 1.14451748752594D0 :W 0.20778486 :H 0.02 :BOX-STRING "eval-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE EVAL-BOX) :INPUT-DRAW-MODE :PW-DOUBLE-INPUTS :OPEN-STATE NIL :OPEN-STATE-W 0.26 :OPEN-STATE-H 0.1)) :X 5 :Y 5 :HITS 1 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.0 :DY 0.0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.2425863098949193D0 :Y 1.133279701858759D0 :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 2,332 | Common Lisp | .l | 4 | 582.25 | 2,177 | 0.731215 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 627d4afe6a197f924d8fc97f718ad3ecebea381470b643a3f3bfadce0c9714e1 | 35,182 | [
-1
] |
35,183 | pascal-triangle.pwgl | bornhoeft_ab-lisp/tutorial/TODO/pascal-triangle.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(in-package :cl-user)
(defun pascal-triangle (num)
\"Generate num rows of Pascal's Triangle\"
(labels ((next-row (row last-num)
(cond ((null row) '(1))
(t (cons (+ last-num (car row))
(next-row (cdr row) (car row))))))
(triangle-b (num prev-row)
(cond ((= num 0) '())
(t (cons prev-row
(triangle-b (1- num)
(next-row prev-row 0)))))))
(triangle-b num '(1))))
;; (pascal-triangle 6)
")) :X 1.972D0 :Y 1.3040000000000012D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 6 :VALUE-STRING "6")) :X 0.7400000000000002D0 :Y 1.408D0 :W 0.26 :H 0.1 :BOX-STRING "pascal-triangle" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::PASCAL-TRIANGLE)) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1) (1 1)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1) (1 2) (2 1)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1) (1 3) (2 3) (3 1)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1) (1 4) (2 6) (3 4) (4 1)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 1) (1 5) (2 10) (3 10) (4 5) (5 1))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.14999999 :GLORTHOX2 5.15 :GLORTHOY1 0.73 :GLORTHOY2 10.27)) :X 319 :Y 238 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 319 :Y 238 :WIDTH 350 :HEIGHT 350))) WIN) :CONNECTION NIL)) :X 1.2879999999999999D0 :Y 1.424D0 :Z -0.1 :W 0.5 :H 0.5 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR))) :X 5 :Y 5 :HITS 1 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.198000002030283D0 :DY -0.2313999997302889D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.2679999985843895D0 :Y 1.2679999994039535D0 :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 3,761 | Common Lisp | .l | 18 | 197.722222 | 2,684 | 0.668538 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 326f77cb44f2c849026f8d5bc359b6154f722984157158718d462c15c8e0e5d4 | 35,183 | [
-1
] |
35,184 | textfile2list.pwgl | bornhoeft_ab-lisp/tutorial/TODO/textfile2list.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 16 (0.9.16-310)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 16) 310)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-BOX) :X 0.1479999999999988D0 :Y 1.8319999999999999D0 :W 0.26 :H 0.025 :BOX-STRING "get-pathname" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :BORDER 0.012) :PW-FUNCTION (QUOTE GET-PATHNAME)) (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "ifile" :CONNECTION NIL :ARG-NAME (QUOTE IFILE) :ARG-TYPE :VAR)) :X 0.7999999999999994D0 :Y 1.4920000000000005D0 :W 0.26 :H 0.1 :BOX-STRING "textfile2list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :TEXT "(mapcar (lambda (x) (mapcar #'read-from-string (split-sequence '(#\\Space #\\Tab) x)))
(with-open-file (si ifile :direction :input)
(loop with eof = (list nil)
for form = (read-line si nil eof)
until (eq form eof)
collect form)))") (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "((12 113 14 151 636 56 6756) (78 9 8 45 37 58 69 70) (70 68 56 45 34 38 67) (sd lk oi jk po jk lk))" :CONNECTION NIL)) :X 0.2560000000000002D0 :Y 1.2759999999999998D0 :W 1.0080000119209292D0 :H 0.11200000149011569D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 1.0080000119209292D0 :OPEN-STATE-H 0.11200000149011569D0) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "#P\"/Users/born/Desktop/numbers.txt\"" :CONNECTION NIL)) :X 0.2959999999999998D0 :Y 1.7200001296997068D0 :W 0.9680000119209291D0 :H 0.10800000149011613D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.9680000119209291D0 :OPEN-STATE-H 0.10800000149011613D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T))) :X 5 :Y 5 :TRANSLY -0.9680000617504118D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2))) :X 780 :Y 607 :WIDTH 391 :HEIGHT 286))) (WINDOW-SELECT WIN) WIN) | 3,707 | Common Lisp | .l | 9 | 407.666667 | 2,475 | 0.734253 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 621469680a042dc965fcaaecfb43eb1d284f93b6d08189b536f2b37825d3bbc7 | 35,184 | [
-1
] |
35,185 | fract-rhythms.pwgl | bornhoeft_ab-lisp/tutorial/TODO/fract-rhythms.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-331)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 331)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :R 0.0 :G 0.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "reps" :CURVAL 5 :VALUE-STRING "5" :ARG-NAME (QUOTE REPS) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "max" :CURVAL 8 :VALUE-STRING "8" :ARG-NAME (QUOTE MAX) :ARG-TYPE :VAR)) :X 1.1320000000000002D0 :Y 1.7360000000000002D0 :W 0.26 :H 0.2 :BOX-STRING "code-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :TEXT "(labels ((a-random (lo hi)
(+ lo (random (+ 1 (abs (- hi lo)))))))
(loop repeat reps
for i = (a-random 1 max)
for j = (a-random 1 i)
for k = (/ i j)
collect (PW:create-list j k)))
") (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "grtms" :CURVAL (LIST (LIST 1 1 1 1) 100 100 100 100) :VALUE-STRING "((1 1 1 1) 100 100 100 100)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enp-obj" :CURVAL "()" :VALUE-STRING "()")) :X 0.8879999999999995D0 :Y 1.3240000000000008D0 :W 0.75 :H 0.17359999 :BOX-STRING "gquantify" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 6 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:GQUANTIFY) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE SCORE-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-SCORE-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE ENP-APPLICATION-WINDOW) :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :Y 100.0 :DURATION 8.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 8.0 :WIDTH 75.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :STEM-X 8.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.6))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 3.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :DURATION 0.6 :STEM-X 16.265 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.6 :TOTAL-DUR 0.6)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.6 :DURATION 0.4 :STEM-X 21.064999 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.4 :TOTAL-DUR 1.6))))) :UNIT-LENGTH 2 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :STEM-X 24.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.2))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :DURATION 0.2 :STEM-X 32.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.2 :TOTAL-DUR 0.2)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH 4 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.2 :DURATION 0.8 :STEM-X 33.864998 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.8 :TOTAL-DUR 1.6))))) :UNIT-LENGTH 2 :TUPLET-P T)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 43.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 4.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :DURATION 0.8 :STEM-X 43.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.8 :TOTAL-DUR 0.8)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.8 :DURATION 0.2 :STEM-X 50.165 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.2 :TOTAL-DUR 1.6))))) :UNIT-LENGTH 2 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :STEM-X 51.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.4))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH 2.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :DURATION 0.4 :STEM-X 59.765 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.4 :TOTAL-DUR 0.4)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH 3 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.4 :DURATION 0.6 :STEM-X 62.965 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.6 :TOTAL-DUR 1.6))))) :UNIT-LENGTH 2 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :STEM-X 67.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 2)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 39.5)))))) (MAKE-INSTANCE (QUOTE PART) :Y -5.625 :DURATION 8.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 8.0 :WIDTH 75.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 2.0 :STEM-X 8.265 :BEAMING-LEVEL -1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 2.0 :TOTAL-DUR 2.333))))) :UNIT-LENGTH 4) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH 2.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.0 :DURATION 0.333 :STEM-X 24.265 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.333 :TOTAL-DUR 0.333)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.333 :DURATION 0.167 :STEM-X 26.931666 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.167 :TOTAL-DUR 2.334))))) :UNIT-LENGTH 1 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.5 :DURATION 1.5 :STEM-X 28.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 1.5 :TOTAL-DUR 2.167))))) :UNIT-LENGTH 3)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 43.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :DURATION 0.5 :STEM-X 43.765 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.667))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.5 :DURATION 0.167 :STEM-X 47.765 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.167 :TOTAL-DUR 0.167)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.5 :UNIT-LENGTH 2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.667 :DURATION 0.333 :STEM-X 49.09833 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.333 :TOTAL-DUR 2.333))))) :UNIT-LENGTH 1 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :DURATION 2.0 :STEM-X 51.765 :BEAMING-LEVEL -1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 2.0 :TOTAL-DUR 2.0))))) :UNIT-LENGTH 4) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :DURATION 0.5 :STEM-X 67.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.5 :STEM-X 71.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 39.5)))))) (MAKE-INSTANCE (QUOTE PART) :Y -11.25 :DURATION 8.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 8.0 :WIDTH 75.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :DURATION 2.5 :STEM-X 8.265 :BEAMING-LEVEL -1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 2.5 :TOTAL-DUR 2.5))))) :UNIT-LENGTH 5) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.5 :DURATION 1.5 :STEM-X 28.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 1.5 :TOTAL-DUR 2.5))))) :UNIT-LENGTH 3)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 43.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 43.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :DURATION 0.5 :STEM-X 51.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.5 :DURATION 0.5 :STEM-X 55.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :DURATION 0.5 :STEM-X 59.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.5 :DURATION 0.5 :STEM-X 63.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :DURATION 0.5 :STEM-X 67.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.5 :STEM-X 71.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 39.5)))))) (MAKE-INSTANCE (QUOTE PART) :Y -16.875 :DURATION 8.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 8.0 :WIDTH 75.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :STEM-X 8.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.333))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 2.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :DURATION 0.333 :STEM-X 16.265 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.333 :TOTAL-DUR 0.333)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.333 :DURATION 0.167 :STEM-X 18.931666 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.167 :TOTAL-DUR 1.334))))) :UNIT-LENGTH 1 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.5 :STEM-X 20.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.167))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.5 :DURATION 0.167 :STEM-X 28.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.167 :TOTAL-DUR 0.167)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :UNIT-LENGTH 2 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.667 :DURATION 0.333 :STEM-X 29.598334 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.333 :TOTAL-DUR 1.333))))) :UNIT-LENGTH 1 :TUPLET-P T) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.0 :STEM-X 32.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 2)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 43.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :DURATION 0.5 :STEM-X 43.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.5 :DURATION 0.5 :STEM-X 47.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :DURATION 0.5 :STEM-X 51.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.5 :DURATION 0.5 :STEM-X 55.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :DURATION 0.5 :STEM-X 59.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.5 :DURATION 0.5 :STEM-X 63.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :DURATION 0.5 :STEM-X 67.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.5 :STEM-X 71.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 39.5)))))) (MAKE-INSTANCE (QUOTE PART) :Y -22.5 :DURATION 8.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE VOICE) :DURATION 8.0 :WIDTH 75.0 :MEASURES (LIST (MAKE-INSTANCE (QUOTE MEASURE) :X 7.5 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :STEM-X 8.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.25))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.0 :DURATION 0.25 :STEM-X 16.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.0 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.25 :DURATION 0.25 :STEM-X 18.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 1.25))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 1.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 1.5 :STEM-X 20.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 2.5 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 2.5 :STEM-X 28.265 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :TOTAL-DUR 1.25))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.5 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.5 :DURATION 0.25 :STEM-X 36.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 0.25)))) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 3.5 :UNIT-LENGTH 1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 3.75 :DURATION 0.25 :STEM-X 38.265 :BEAMING-LEVEL 2 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.25 :TOTAL-DUR 1.25))))) :UNIT-LENGTH 1)) :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 4.0) :METRONOME (MAKE-INSTANCE (QUOTE METRONOME) :FORCE-SHOW-METRONOME-P T)) (MAKE-INSTANCE (QUOTE MEASURE) :X 43.0 :START-TIME 4.0 :DURATION 4.0 :BEAT-OBJECTS (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 4.0 :UNIT-LENGTH 1.0 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 4.0 :STEM-X 43.765 :BEAMING-LEVEL 0 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE)))))) :UNIT-LENGTH 2) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.0 :DURATION 0.5 :STEM-X 51.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 5.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 5.5 :DURATION 0.5 :STEM-X 55.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.0 :DURATION 0.5 :STEM-X 59.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 6.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 6.5 :DURATION 0.5 :STEM-X 63.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.0 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.0 :DURATION 0.5 :STEM-X 67.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1) (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :SUB-BEAT-LIST (LIST (MAKE-INSTANCE (QUOTE BEAT) :START-TIME 7.5 :UNIT-LENGTH -1 :BEAT-CHORD (MAKE-INSTANCE (QUOTE CHORD) :START-TIME 7.5 :DURATION 0.5 :STEM-X 71.0 :BEAMING-LEVEL 1 :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :DUR 0.5 :TOTAL-DUR 0.5))))) :UNIT-LENGTH 1)) :MEASURE-NUMBER 1 :TIME-SIGNATURE (MAKE-INSTANCE (QUOTE TIME-SIGNATURE) :HIGH 8 :LOW 8 :X 39.5))))))) :X 150 :Y 150 :TITLE "Score-Editor1" :X 1150 :Y 280 :WIDTH 1011 :HEIGHT 879))) WIN) :CONNECTION NIL)) :X 1.2960000000000003D0 :Y 0.8919999999999999D0 :W 0.7 :H 0.32 :BOX-STRING "Score-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "score") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "rtms/times")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SCORE-EDITOR))) :X 5 :Y 5 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.02749999964609784D0 :DY -0.22360000457614704D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.27599999858439D0 :Y 1.090400013118983D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.11000000203028293D0 :DY -0.21939999656379228D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8679999985843891D0 :Y 1.4959999979138377D0 :DX 0.0 :DY 0.0))) :X 555 :Y 581 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 25,110 | Common Lisp | .l | 11 | 2,279.636364 | 24,028 | 0.712231 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 65badac866bbae5de274c4925dbff6add3a32d18194cb9fe49bd70b8e6e96c50 | 35,185 | [
-1
] |
35,186 | even_odd_mk-profile.pwgl | bornhoeft_ab-lisp/tutorial/TODO/constraints/even_odd_mk-profile.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-329)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 329)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PMC-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "search-space" :CURVAL (LIST (QUOTE 4*) (LIST (LIST (QUOTE |0_3|)))) :VALUE-STRING "(4* ((0_3)))" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "rules" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "term-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :R 0.85 :G 0.85 :B 0.85 :BOX-STRING "heur-rules" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "rnd?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sol-mode" :CURVAL 1 :MINVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "prep-fns" :CURVAL "()" :VALUE-STRING "()")) :X 1.7399999999999998D0 :Y 0.24000000000000066D0 :W 0.69 :H 0.2508 :BOX-STRING "Multi-PMC" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 3 3) :ORIG-GROUPING-LIST (LIST 1 3) :EXTENSION-PATTERN (LIST 3 4) :EXTENSION-LIMIT 11 :Y-PROPORTIONS (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE MULTI-PMC) :CURRENT-EXTENSION-PATTERN-INDEX* 1 :CURRENT-EXTENSION-PATTERN-INDEX 0 :STORED-EXTEND-INPUTS-LIST (LIST (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "procs?" :MINVAL 0 :MAXVAL 1 :MENU-LIST :BOOLEAN-LIST :MENU-LIST-STRING "T") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "p-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "r-cnt" :CURVAL 2 :MINVAL 1 :VALUE-STRING "2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "schedules" :CURVAL "()" :VALUE-STRING "()"))) :ALL-SOLS (LIST (LIST 48 72 58 71 63 70 67 69 68 66 70 57 70 53 71 50 71 49 72 48))) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 20 :VALUE-STRING "20" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL (LIST (QUOTE COMMON-LISP-USER::|48_72|)) :VALUE-STRING "(48_72)" :CONNECTION NIL)) :X 0.5759999999999996D0 :Y 0.32399999999999985D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL 20 :VALUE-STRING "20")) :X 0.3680000000000003D0 :Y 1.6439999999999997D0 :W 0.3079999904632569D0 :H 0.1760000014901162D0 :BOX-STRING "value-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE VALUE-BOX) :OPEN-STATE-W 0.3079999904632569D0 :OPEN-STATE-H 0.1760000014901162D0) (MAKE-INSTANCE (QUOTE PWGL-CHORD-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-CHORD-SUBBOX) :R 1.0 :G 1.0 :B 1.0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE CHORD-EDITOR-WINDOW) :SPACING 0.3 :MODE :ARPEGGIO :PARTS (LIST (MAKE-INSTANCE (QUOTE PART) :Y 45.0 :DURATION 0.0 :INSTRUMENT (MAKE-INSTANCE (QUOTE INSTRUMENT) :SCORE-NAME "P" :WRITTEN-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :SOUNDING-CLEF (MAKE-INSTANCE (QUOTE TREBLE-STAFF))) :STAFF (MAKE-INSTANCE (QUOTE TREBLE-STAFF)) :VOICE-LIST (LIST (MAKE-INSTANCE (QUOTE ENP-CHORD-EDITOR) :X 5.0 :WIDTH NIL :CHORDS (LIST (MAKE-INSTANCE (QUOTE CHORD) :NOTES (LIST (MAKE-INSTANCE (QUOTE NOTE) :MIDI 48) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 72) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 58 :DELTA-X -6 :ALT-DELTA-X -12) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 71 :DELTA-X -6) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 63 :ALT-DELTA-X -18) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 70 :DELTA-X -18 :ALT-DELTA-X -30) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 67 :DELTA-X -6) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 69 :ALT-DELTA-X -24) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 68 :DELTA-X -12 :ALT-DELTA-X -12) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 66) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 70 :DELTA-X -24 :ALT-DELTA-X -36) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 57) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 70 :DELTA-X -30 :ALT-DELTA-X -42) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 53) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 71 :DELTA-X -12) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 50 :DELTA-X -18) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 71 :DELTA-X -36) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 49 :DELTA-X -12 :ALT-DELTA-X -12) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 72 :DELTA-X -18) (MAKE-INSTANCE (QUOTE NOTE) :MIDI 48 :DELTA-X -6)))) :PIXELS/SEC 5.875)))) :SCALEFX 2.3 :SCALEFY 2.3 :TRANSLX 18.0 :TRANSLY -8.0 :X 258 :Y 542 :STAFF (MAKE-INSTANCE (QUOTE CHORD-EDITOR-PIANO-STAFF)) :TITLE "Chord-Editor2" :X 258 :Y 542 :WIDTH 350 :HEIGHT 432))) WIN) :CONNECTION NIL)) :X 1.024000000000001D0 :Y -0.12399989891052199D0 :W 2.5080000059604646D0 :H 0.5 :BOX-STRING "Chord-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "chord") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "pitches")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CHORD-EDITOR) :OPEN-STATE-W 2.5080000059604646D0 :OPEN-STATE-H 0.5) (MAKE-INSTANCE (QUOTE PWGL-VALUES-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "r1" :CURVAL NIL :VALUE-STRING "nil") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "more-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "more-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "more-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "more-rules" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "more-rules" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 2.62D0 :Y 0.6440001010894769D0 :W 0.26 :H 0.46799997 :BOX-STRING "collect-rules" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1 1 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE JBS-CONSTRAINTS:COLLECT-RULES) :CURRENT-EXTENSION-PATTERN-INDEX* 5) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :R 0.0 :G 0.7810202 :B 0.025131612 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0.0 0.0) (0.07455781131828782D0 0.37035968666694264D0) (0.2548299117806827D0 0.7325898856536109D0) (0.4855782003725481D0 0.8851078641743133D0) (0.7271428149921573D0 0.9613668534346647D0) (1.0 1.0))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.03 :GLORTHOX2 1.03 :GLORTHOY1 -0.03 :GLORTHOY2 1.03)) :X 869 :Y 211 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 869 :Y 211 :WIDTH 350 :HEIGHT 350))) WIN))) :X 3.436D0 :Y 2.0160001010894777D0 :W 0.5 :H 0.5 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR)) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :R 0.8325792 :G 0.058785577 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0.0 1) (0.2548299117806827D0 0.9384891566565592D0) (0.4639455483170608D0 0.8088488749139622D0) (0.5072108524280355D0 0.5381294630397153D0) (0.6442176487794558D0 0.23690645546132805D0) (0.7668026770938842D0 0.09964027479269588D0) (1.0 0))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.03 :GLORTHOX2 1.03 :GLORTHOY1 -0.03 :GLORTHOY2 1.03)) :X 869 :Y 211 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 869 :Y 211 :WIDTH 350 :HEIGHT 350))) WIN))) :X 4.076000001490116D0 :Y 2.0080000995993617D0 :W 0.5 :H 0.5 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR)) (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "weight" :CURVAL 213 :VALUE-STRING "213" :ARG-NAME (QUOTE WEIGHT) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "even-profile" :CONNECTION NIL :ARG-NAME (QUOTE EVEN-PROFILE) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "odd-profile" :CONNECTION NIL :ARG-NAME (QUOTE ODD-PROFILE) :ARG-TYPE :VAR)) :X 4.228D0 :Y 0.39200010108947714D0 :W 0.3439999904632569D0 :H 0.3 :BOX-STRING "mk-profile-modified (code-box)" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :OPEN-STATE-W 0.3439999904632569D0 :OPEN-STATE-H 0.3 :TEXT "`(:HEURISTIC * ?1
(?IF (- ,weight (ABS (- ?1 (if (oddp len)
(NTH (1- LEN) ',even-profile)
(NTH (1- LEN) ',odd-profile)) )))))") (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.7810202 :B 0.025131612 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "object" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "no-of-points" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL)) :X 3.8920000000000004D0 :Y 1.3080001010894775D0 :W 0.26 :H 0.16 :BOX-STRING "pwgl-sample" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SAMPLE)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.8325792 :G 0.058785577 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "object" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "no-of-points" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL)) :X 4.692000001490117D0 :Y 1.2920000995993615D0 :W 0.26 :H 0.16 :BOX-STRING "pwgl-sample" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SAMPLE)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.7810202 :B 0.025131612 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "vals?" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "minout" :CURVAL 48 :VALUE-STRING "48" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "maxout" :CURVAL 72 :VALUE-STRING "72" :CONNECTION NIL)) :X 3.88D0 :Y 0.9760001010894777D0 :W 0.26 :H 0.24 :BOX-STRING "g-scaling" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:G-SCALING)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.8325792 :G 0.058785577 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "vals?" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "minout" :CURVAL (LIST (QUOTE QUOTE) 48) :VALUE-STRING "`48" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "maxout" :CURVAL 72 :VALUE-STRING "72" :CONNECTION NIL)) :X 4.732000001490116D0 :Y 0.9640000995993621D0 :W 0.26 :H 0.24 :BOX-STRING "g-scaling" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:G-SCALING)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "begin" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "step" :CURVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "end" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL)) :X 1.3199999999999999D0 :Y 0.5600001010894768D0 :W 0.26 :H 0.24 :BOX-STRING "arithm-ser" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:ARITHM-SER)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL 48 :VALUE-STRING "48")) :X 1.2399999999999998D0 :Y 1.1240001010894783D0 :W 0.26 :H 0.1 :BOX-STRING "value-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE VALUE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL 72 :VALUE-STRING "72")) :X 1.5760000014901152D0 :Y 0.836000099599362D0 :W 0.26 :H 0.1 :BOX-STRING "value-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE VALUE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.7810202 :B 0.025131612 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "midis" :CURVAL 60 :VALUE-STRING "60" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "approx" :CURVAL 2 :VALUE-STRING "2")) :X 3.8999999999999995D0 :Y 0.6000001010894778D0 :W 0.2159999809265134D0 :H 0.1 :BOX-STRING "approx-midi" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:APPROX-MIDI) :OPEN-STATE-W 0.2159999809265134D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.8325792 :G 0.058785577 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "midis" :CURVAL 60 :VALUE-STRING "60" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "approx" :CURVAL 2 :VALUE-STRING "2")) :X 4.736000001490116D0 :Y 0.5720000995993617D0 :W 0.2159999809265134D0 :H 0.1 :BOX-STRING "approx-midi" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:APPROX-MIDI) :OPEN-STATE-W 0.2159999809265134D0 :OPEN-STATE-H 0.1) (MAKE-INSTANCE (QUOTE JBS-CONSTRAINTS::PMC-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curve-min" :CURVAL 60 :VALUE-STRING "60") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curve-max" :CURVAL 72 :VALUE-STRING "72") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "steps" :CURVAL 10 :VALUE-STRING "10") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "profile" :CURVAL NIL :VALUE-STRING "nil" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "decimals" :VALUE-STRING "0") (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "mode?" :CURVAL 1 :MINVAL 0 :MAXVAL 1 :MENU-LIST (LIST (LIST "true/false" :TRUE/FALSE) (LIST "heuristic" :HEURISTIC)) :MENU-LIST-STRING (LIST "heuristic" :HEURISTIC)) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "weight" :CURVAL 213 :VALUE-STRING "213")) :X 3.1559999999999993D0 :Y 0.5240001010894777D0 :W 0.52 :H 0.32 :BOX-STRING "mk-profile-rule" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2 2 1) :ORIG-GROUPING-LIST (LIST 2 2 2 1) :BORDER 0.012) :PW-FUNCTION (QUOTE JBS-CONSTRAINTS:MK-PROFILE-RULE))) :X 5 :Y 5 :TRANSLY 0.6559998631477355D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 1 :PWBOX2 17 :INPUT-BOX 3 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.417666680816561D0 :DY -0.0420499972626569D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.6959999823421233D0 :Y 1.4560001024305822D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 5 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.5099999979697167D0 :DY 0.04460001872479902D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.5849999998509885D0 :Y 0.03700009039789398D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 16 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.676999996330589D0 :DY -0.11900001204758915D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.341999999254942D0 :Y 0.1580001001209026D0 :DX 0.1640000000000006D0 :DY -0.22399999999999976D0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.25899999558553067D0 :DY -0.08740000457316666D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.192999999850988D0 :Y 0.4250001012757423D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 16 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.06799999796971657D0 :DY -0.09140000166744011D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.716000000074506D0 :Y 0.6640001063048846D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 15 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.01599999796971674D0 :DY -0.12740000166743992D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.879999998584389D0 :Y 0.6760001077950002D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.5080000020302835D0 :DY 0.027999999687075672D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.682000000745058D0 :Y 0.6660000996738678D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.0820000012852256D0 :DY 0.03400000043213347D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.829999999254942D0 :Y 0.6660000996738678D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.6760000027753413D0 :DY -0.08039999820291999D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.697000001341104D0 :Y 0.9690001008287079D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.2500000020302833D0 :DY -0.07439999745786219D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.8449999998509883D0 :Y 0.9690001008287079D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.030000006798654777D0 :DY -0.11540005221217853D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1159999823421236D0 :Y 0.28000010734796455D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2399999987147745D0 :DY -0.19799999956786696D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.2849999998509883D0 :Y 0.6810000993385916D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.07599999796971679D0 :DY -0.2827999983280902D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.2999999985843896D0 :Y 0.9840001004934318D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 1 :PWBOX2 0 :INPUT-BOX 3 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.17666666680946963D0 :DY -0.02110007192939456D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.4649999977648256D0 :Y 0.10100013781338868D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.4883333333395423D0 :DY -0.02110007192939456D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7049999998509882D0 :Y 0.10100013781338868D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.049999997969717214D0 :DY -0.09880000086128682D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.7120000000745055D0 :Y 1.0720001045167447D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.013999997969717182D0 :DY -0.12680000086128707D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.8599999985843896D0 :Y 1.0880001060068607D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.7900000027753414D0 :DY -0.33309994767606255D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.657000001341105D0 :Y 1.4129999997392293D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 1 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.01966667198762284D0 :DY -0.10969999907910833D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 4.672000000074506D0 :Y 1.4480001009404662D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 1.5920000020302832D0 :DY -0.37909994693100457D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.8569999998509888D0 :Y 1.4129999997392293D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 1 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.10233332801237705D0 :DY -0.15969999907910837D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 3.87199999858439D0 :Y 1.4560001024305822D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 0 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.14149999975785588D0 :DY -0.261999943159521D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0039999985843906D0 :Y -0.07080001220107013D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :RIGHT-ANGLE :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.09399999796971681D0 :DY -0.32339999824017296D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9239999985843896D0 :Y 1.795999999403953D0 :DX 0.3680000000000003D0 :DY -0.06800000000000006D0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.339000004414469D0 :DY 0.05230000040680194D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.6479999985843899D0 :Y 0.035999999403953265D0 :DX -0.07199999999999962D0 :DY -0.14800000000000013D0))) :X 5 :Y 22 :WIDTH 1319 :HEIGHT 748))) (WINDOW-SELECT WIN) WIN) | 30,396 | Common Lisp | .l | 7 | 4,331.857143 | 20,199 | 0.743699 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 946000d5232f323e9433dfb45d6d59e678488813b7cff2d643a3c9034e6c1197 | 35,186 | [
-1
] |
35,187 | vincenot.pwgl | bornhoeft_ab-lisp/tutorial/TODO/constraints/vincenot.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-318)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 318)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "; true/false
(* ?1 (?IF ; <=== everything goes there (T or NIL)
(NOT (MEMBER ?1 (REST RL) :TEST (QUOTE EQUALP)))
; so the T or NIL comes after the NOT function
))
; heuristic
(* ?1 (?IF ; <=== everything goes there (heuristic weight)
(IF
(NOT (MEMBER ?1 (REST RL) :TEST (QUOTE EQUALP)))
; a T or NIL value comes from the NOT, as well
1 ; according to the truth value, the 1 (T)
0) ; or 0 (NIL) are sent to the ?IF
)) ")) :X 1.092D0 :Y 1.7080000000000002D0 :Z -0.1 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX))) :X 5 :Y 5 :X 5 :Y 22 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 1,337 | Common Lisp | .l | 16 | 78.125 | 374 | 0.651022 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | d56f985e2de423afdf15cc41e8ee84a83b2f67c117363b9efe675b74e75a259d | 35,187 | [
-1
] |
35,188 | sample-env.pwgl | bornhoeft_ab-lisp/tutorial/Envelopes/sample-env.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-331)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 331)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 849 :HEIGHT 702) :VALUE-STRING "(in-package :cl-user)
(defun sample-env (env samples)
\"Taking any number of samples from an envelope of x/y-values.
Envelope can be a list of xy-value pairs or a list containing a list of x-values and a list of y-values.\"
(labels ((split-xy (lst)
\"Split a list of x/y-values into a list of x-values and a list of y-values.\"
(loop for i from 0 to (- (length lst) 1) by 2
for j from 1 by 2
collect (nth i lst) into xlis
collect (nth j lst) into ylis
finally (return (list xlis ylis))))
(resample-x (lst samples)
\"Resample a list of x-values to any number of equidistant x-values in the same range.\"
(let* ((start (first lst))
(end (first (reverse lst)))
(dist (- end start))
(stp (/ dist (- samples 1))))
(loop repeat samples
for i from start by stp collect i)))
(map-range (a1 a2 b1 b2 s)
\"Calculates the value s according to a range between a1 and a2 into a new range between b1 and b2.\"
(* 1.0 (+ b1
(/ (* (- s a1)
(- b2 b1))
(- a2 a1))))))
(let* ((type? (numberp (first env)))
(xy (if type? (split-xy env)))
(xlst (if type? (first xy) (first env)))
(ylst (if type? (second xy) (second env)))
(rs-x (resample-x xlst samples)))
(loop for i in rs-x
when type? collect i into results
collect
(loop
for x in xlst
for xc in (cdr xlst)
for y in ylst
for yc in (cdr ylst)
for r1 = (map-range x xc 0 1 i)
for r2 = (map-range 0 1 y yc r1)
when (>= xc i x) do (return r2))
into results
finally (if type? (return results) (return (list rs-x results)))))))
;; (sample-env '(0 1 1 3 2 2 3 4) 5) => ((0 3/4 3/2 9/4 3) (1.0 2.5 2.5 2.5 4.0))
;; (sample-env '((0 1 2 3) (1 3 2 4)) 5) => ((0 3/4 3/2 9/4 3) (1.0 2.5 2.5 2.5 4.0))
;; (sample-env '((0 2 3 6) (60 54 83 69)) 5) => ((0 3/4 3/2 9/4 3) (1.0 2.5 2.5 2.5 4.0))")) :X 0.6639999999999997D0 :Y 1.2080000839233405D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 60) (2 54) (3 83) (6 69))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.17999999 :GLORTHOX2 6.18 :GLORTHOY1 53.13 :GLORTHOY2 83.87)) :X 317 :Y 305 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 317 :Y 305 :WIDTH 350 :HEIGHT 350))) WIN) :CONNECTION NIL :PATCH-LEVEL-EDITING? T)) :X 1.184000000000001D0 :Y 1.9120000000000013D0 :W 0.7240000000000002D0 :H 0.5039999999999996D0 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR) :OPEN-STATE-W 0.7240000000000002D0 :OPEN-STATE-H 0.5039999999999996D0) (MAKE-INSTANCE (QUOTE PWGL-2D-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE 2D-CONSTRUCTOR-FUNCTION) :MINVAL 0 :MAXVAL 5 :MENU-LIST :2D-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":bpf") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "xs/l" :CURVAL (LIST (LIST 0 1 2 3) (LIST 1 3 2 4)) :VALUE-STRING "((0 1 2 3) (1 3 2 4))" :CONNECTION NIL)) :X 0.7000000000000006D0 :Y 1.8880000000000008D0 :W 0.45 :H 0.166 :BOX-STRING "2d-bpf-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-BPF-CONSTRUCTOR)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "object" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "no-of-points" :CURVAL 4 :VALUE-STRING "4" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "include-x?" :MINVAL 0 :MAXVAL 1 :MENU-LIST (LIST "T" "nil") :MENU-LIST-STRING "T")) :X 1.1319999999999997D0 :Y 1.2800000000000007D0 :W 0.26 :H 0.2268 :BOX-STRING "pwgl-sample" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SAMPLE) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 1.0 :VALUE-STRING "1.0")) :X 1.56D0 :Y 1.2680000000000016D0 :W 0.52 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(((0.0 60.0) (0.54545457 58.363636) (1.0909091 56.727272) (1.6363636 55.090908) (2.1818183 59.272728) (2.7272728 75.09091) (3.2727273 81.72727) (3.8181818 79.181816) (4.3636365 76.63636) (4.909091 74.09091) (5.4545455 71.545456) (6.0 69.0)))" :CONNECTION NIL)) :X 0.903999999999999D0 :Y 0.9640000000000009D0 :W 1.1800000119209289D0 :H 0.1240000014901157D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :INPUT-DRAW-MODE :PW-DOUBLE-INPUTS :OPEN-STATE-W 1.1800000119209289D0 :OPEN-STATE-H 0.1240000014901157D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 60.0) (6/11 58.363636) (12/11 56.727272) (18/11 55.090908) (24/11 59.272728) (30/11 75.09091) (36/11 81.72727) (42/11 79.181816) (48/11 76.63636) (54/11 74.09091) (60/11 71.545456) (6 69.0))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.17999999 :GLORTHOX2 6.18 :GLORTHOY1 54.291817 :GLORTHOY2 82.52636)) :X 317 :Y 305 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 317 :Y 305 :WIDTH 648 :HEIGHT 397))) WIN) :CONNECTION NIL :PATCH-LEVEL-EDITING? T)) :X 2.024000001490118D0 :Y 0.6799999985098846D0 :W 0.8200000000000003D0 :H 0.5720000000000001D0 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR) :OPEN-STATE-W 0.8200000000000003D0 :OPEN-STATE-H 0.5720000000000001D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST (LIST 0) (LIST 1)) :VALUE-STRING "((0) (1))" :CONNECTION NIL)) :X 0.9800000000000004D0 :Y 0.7280000686645507D0 :W 0.26 :H 0.1 :BOX-STRING "flat-once" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:FLAT-ONCE)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "matrix" :CURVAL (LIST (LIST 1 2)) :VALUE-STRING "((1 2))" :CONNECTION NIL)) :X 1.1320000000000006D0 :Y 0.564000068664551D0 :W 0.26 :H 0.1 :BOX-STRING "mat-trans" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:MAT-TRANS)) (MAKE-INSTANCE (QUOTE PWGL-2D-CONSTRUCTOR-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "selector" :PWGL-ACTION-FUNCTION (QUOTE 2D-CONSTRUCTOR-FUNCTION) :MINVAL 0 :MAXVAL 5 :MENU-LIST :2D-CONSTRUCTOR-CLASSES :MENU-LIST-STRING ":bpf") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "xs/l" :CURVAL (LIST (LIST 0 1 2 3) (LIST 1 3 2 4)) :VALUE-STRING "((0 1 2 3) (1 3 2 4))" :CONNECTION NIL)) :X 1.5120000014901165D0 :Y 0.6199999985098845D0 :W 0.45 :H 0.166 :BOX-STRING "2d-bpf-constructor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-BPF-CONSTRUCTOR)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "((0 2 3 6) (60 54 83 69))")) :X 0.028000002980231642D0 :Y 1.9400000809431082D0 :W 0.6000000119209292D0 :H 0.11200000149011658D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :X-PROPORTIONS (LIST (LIST 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.6000000119209292D0 :OPEN-STATE-H 0.11200000149011658D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "env" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 5 :VALUE-STRING "5" :CONNECTION NIL)) :X 0.3400000014901159D0 :Y 1.4320000824332229D0 :W 0.52 :H 0.1 :BOX-STRING "sample-env" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::SAMPLE-ENV)) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 0.552D0 :Y 0.3480000839233397D0 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 12 :VALUE-STRING "12")) :X 0.7479999999999998D0 :Y 1.59200008392334D0 :W 0.26 :H 0.1 :BOX-STRING "num-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUM-BOX)) (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-BOX) :R 1.0 :G 0.0 :B 0.0 :X 2.128000000000001D0 :Y 1.58000008392334D0 :W 0.4719999904632566D0 :H 0.02500000037252903D0 :BOX-STRING "sample-env xy-pairs" :PW-FUNCTION (QUOTE PWGL-ABSTRACTION) :OPEN-STATE-W 0.4719999904632566D0 :OPEN-STATE-H 0.02500000037252903D0 :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-ABSTRACTION-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(0 1.0 3/4 2.5 3/2 2.5 9/4 2.5 3 4.0)" :CONNECTION NIL)) :X 0.4120000014901164D0 :Y 0.7440000824332254D0 :W 0.828000011920929D0 :H 0.11600000149011614D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :X-PROPORTIONS (LIST (LIST 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.828000011920929D0 :OPEN-STATE-H 0.11600000149011614D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(0 1 1 3 2 2 3 4)")) :X 0.2560000000000002D0 :Y 1.1400000839233413D0 :W 0.4360000119209291D0 :H 0.10800000149011613D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :X-PROPORTIONS (LIST (LIST 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.4360000119209291D0 :OPEN-STATE-H 0.10800000149011613D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "env" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 5 :VALUE-STRING "5")) :X 0.7280000000000007D0 :Y 1.0440000839233417D0 :W 0.52 :H 0.1 :BOX-STRING "sample-env" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::SAMPLE-ENV))) :X 150 :Y 150 :TRANSLY -0.4479996206760406D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 0 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.06699999484047314D0 :DY -0.08939999898523077D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.3920000000745061D0 :Y 0.9040000833272952D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.08200000333413482D0 :DY -0.09939999824017298D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7079999985843903D0 :Y 0.9920000833272948D0 :DX 0.0 :DY 0.0))) :TITLE "sample-env xy-pairs" :X 150 :Y 150 :WIDTH 393 :HEIGHT 261))) WIN) :BOX-DOCUMENTATION "")) :X 5 :Y 5 :TRANSLY 0.09999953818321232D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.15850000262633035D0 :DY -0.02640000177174806D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.0040000000745075D0 :Y 0.3940000061690814D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.40499999964609757D0 :DY 0.13064996084570924D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.4770000013411049D0 :Y 0.1730000841096042D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3052499974966052D0 :DY -0.08499999196082375D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6955000002384186D0 :Y 0.42400006806850455D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.08200000203028313D0 :DY -0.1511000394374129D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.096999999850988D0 :Y 1.4370000836625696D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.00600000605359674D0 :DY -0.023399998985231374D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8799999838322399D0 :Y 1.4520000833272935D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.2227500057518481D0 :DY -0.4349999988451596D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6015000034570694D0 :Y 1.2920000818371764D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.06100000482425039D0 :DY 0.15664996308088353D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.664999999850989D0 :Y 1.7730000806823374D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.031000004079192567D0 :DY -0.131399997495115D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.3200000000745056D0 :Y 1.7880000803470613D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.36000000203028315D0 :DY -0.03739999824017293D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1119999985843903D0 :Y 0.5880000680685043D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.10799999666586568D0 :DY -0.09139996390789773D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9599999985843901D0 :Y 0.7999999994039548D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.07300000441446852D0 :DY -0.2053999982401733D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.104000013336538D0 :Y 1.1279999994039552D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.12799999796971662D0 :DY -0.048000001631676836D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5399999985843898D0 :Y 0.9932000066339977D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.04033333297943065D0 :DY -0.12569999907910856D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1119999985843894D0 :Y 1.3480000013411062D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1845000026263297D0 :DY -0.23840000363439318D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1639999985843908D0 :Y 1.6620000076591977D0 :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 799 :HEIGHT 570))) (WINDOW-SELECT WIN) WIN) | 23,938 | Common Lisp | .l | 49 | 477.285714 | 21,280 | 0.72526 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 2b02101374cba48149efff5303e9884a076f4b21f2af46042cab95c0df437b8c | 35,188 | [
-1
] |
35,189 | 02-weighted-tendency.pwgl | bornhoeft_ab-lisp/tutorial/Random/02-weighted-tendency.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-342)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 342)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 874 :HEIGHT 660) :VALUE-STRING "(in-package :cl-user)
(defun weighted-random (n weight-list)
(let ((wlis (loop for j from 0 below (- (length weight-list) 1) by 2
append (make-list (round (nth (+ 1 j) weight-list)) :initial-element (nth j weight-list)) into reslis
finally (return reslis))))
(loop repeat n
collect (nth (random (- (length wlis) 1)) wlis))))
; (weighted-random 20 '(1 10 2 20 3 70))
")) :X 1.1920000000000015D0 :Y 1.3079999999999999D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX) :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.972D0 :Y 1.6399999999999997D0 :W 0.325 :H 0.099999994 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "test" :CURVAL "()" :VALUE-STRING "()") (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "accum" :CURVAL 1 :STEPVAL 0.2 :MINVAL 0 :MAXVAL 5 :MENU-LIST :PWGL-MAP-ACCUM-FNS :MENU-LIST-STRING ":append")) :X 0.36199999630451263D0 :Y 1.2239999880790702D0 :W 0.52 :H 0.24719998 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 1 1) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP) :CURRENT-EXTENSION-PATTERN-INDEX* 2) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(-1 -1 -1 -1 -1 -1 1 -1 -1 -1 -1 1 1 -1 -1 -1 -1 -1 -1 1 -1 1 -1 -1 -1 1 -1 1 1 1 -1 1 -1 1 -1 -1 1 -1 1 1 -1 1 1 1 1 1 1 1 1 1)" :CONNECTION NIL)) :X 0.6400000000000001D0 :Y 0.8919998874664303D0 :W 1.864000011920929D0 :H 0.10800000149011613D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 1.864000011920929D0 :OPEN-STATE-H 0.10800000149011613D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "begin" :CURVAL (LIST -1 90 1 10) :VALUE-STRING "(-1 90 1 10)") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "end" :CURVAL (LIST -1 20 1 80) :VALUE-STRING "(-1 20 1 80)") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "samples" :CURVAL 50 :VALUE-STRING "50") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "curves" :CURVAL 1 :VALUE-STRING "1")) :X 0.516D0 :Y 1.93999988746643D0 :W 0.875999980926514D0 :H 0.17199999642372133D0 :BOX-STRING "interpolation" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 2) :ORIG-GROUPING-LIST (LIST 2 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :X-PROPORTIONS (LIST (LIST 1 1) (LIST 0.8317073182692829D0 0.8536585376254626D0)) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:INTERPOLATION) :OPEN-STATE-W 0.875999980926514D0 :OPEN-STATE-H 0.17199999642372133D0) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 -1) (1 -1) (2 -1) (3 -1) (4 -1) (5 -1) (6 1) (7 -1) (8 -1) (9 -1) (10 -1) (11 1) (12 1) (13 -1) (14 -1) (15 -1) (16 -1) (17 -1) (18 -1) (19 1) (20 -1) (21 1) (22 -1) (23 -1) (24 -1) (25 1) (26 -1) (27 1) (28 1) (29 1) (30 -1) (31 1) (32 -1) (33 1) (34 -1) (35 -1) (36 1) (37 -1) (38 1) (39 1) (40 -1) (41 1) (42 1) (43 1) (44 1) (45 1) (46 1) (47 1) (48 1) (49 1))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -1.4699999 :GLORTHOX2 50.47 :GLORTHOY1 -1.06 :GLORTHOY2 1.06 :CO-ORDINATE-LIMITS (LIST -1.0 1.0 -1.0 1.0))) :X 354 :Y 458 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 354 :Y 458 :WIDTH 350 :HEIGHT 350))) WIN) :CONNECTION NIL)) :X 0.6759999999999997D0 :Y 0.6279996719360352D0 :W 1.8240000000000003D0 :H 0.33599999999999986D0 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR) :OPEN-STATE-W 1.8240000000000003D0 :OPEN-STATE-H 0.33599999999999986D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "n" :CURVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "weight-list" :CURVAL NIL :CONNECTION NIL)) :X 0.6919999999999993D0 :Y 1.3959999427795409D0 :W 0.4239999809265136D0 :H 0.10000000149011612D0 :BOX-STRING "weighted-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :X-PROPORTIONS (LIST (LIST 0.27999999266404285D0 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::WEIGHTED-RANDOM) :OPEN-STATE-W 0.4239999809265136D0 :OPEN-STATE-H 0.10000000149011612D0)) :X 5 :Y 5 :SCALEFX 0.5 :SCALEFY 0.5 :TRANSLY -0.0880003182888031D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.026000006262212328D0 :DY -0.05339997465908586D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9019999786466366D0 :Y 1.2559999421834945D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.03974999379739108D0 :DY -0.08540003057569234D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1359999823421232D0 :Y 1.4800000073015687D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004000006262212752D0 :DY -0.05980005808919642D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6199999985843898D0 :Y 0.9168000070154658D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.10100000333413495D0 :DY -0.20540010749548654D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6559999985843894D0 :Y 0.7439998868703839D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 1 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.07600000441446875D0 :DY -0.17139994264394032D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9519999985843897D0 :Y 1.7079998923838132D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.3419999948889023D0 :Y 1.4800000073015687D0 :DX 0.0 :DY 0.0))) :WINDOW-DOCUMENTATION "© 2015
Achim Bornhoeft
Tendency of weighted random numbers." :X 587 :Y 225 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 10,215 | Common Lisp | .l | 14 | 724.357143 | 9,115 | 0.724064 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | e92af340456875feb93744c1ead3ed0c5890560b30573733c559ec9b0989ae1e | 35,189 | [
-1
] |
35,190 | 01-weighted-random.pwgl | bornhoeft_ab-lisp/tutorial/Random/01-weighted-random.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-342)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 342)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 874 :HEIGHT 660) :VALUE-STRING "(in-package :cl-user)
(defun weighted-random (n weight-list)
(let ((wlis (loop for j from 0 below (- (length weight-list) 1) by 2
append (make-list (round (nth (+ 1 j) weight-list)) :initial-element (nth j weight-list)) into reslis
finally (return reslis))))
(loop repeat n
collect (nth (random (- (length wlis) 1)) wlis))))
; (weighted-random 20 '(1 10 2 20 3 70))
")) :X 1.0040000000000005D0 :Y 1.8760000000000013D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX) :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(1 10)
(2 20)
(3 70)")) :X 0.06400000000000006D0 :Y 1.9999999999999996D0 :W 0.22000001192092889D0 :H 0.23600000149011624D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.22000001192092889D0 :OPEN-STATE-H 0.23600000149011624D0 :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "matrix" :CURVAL (LIST (LIST 1 2)) :VALUE-STRING "((1 2))" :CONNECTION NIL)) :X 0.35200000000000076D0 :Y 1.7680000000000003D0 :W 0.26 :H 0.1 :BOX-STRING "mat-trans" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:MAT-TRANS)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 10 :VALUE-STRING "10" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "elem" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.5999999999999992D0 :Y 1.1400000000000002D0 :W 0.52 :H 0.1 :BOX-STRING "create-list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK:CREATE-LIST)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.8160000000000003D0 :Y 1.4840000000000005D0 :W 0.325 :H 0.17359999 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.32199999630451215D0 :Y 0.9799999880790713D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.5040000000000005D0 :Y 1.5760000000000006D0 :W 0.26 :H 0.1 :BOX-STRING "first" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE FIRST)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.1880000000000006D0 :Y 1.516D0 :W 0.26 :H 0.1 :BOX-STRING "second" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SECOND)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.5181 :G 0.6081 :B 0.6081 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.6000000000000005D0 :Y 0.7840000000000007D0 :W 0.26 :H 0.1 :BOX-STRING "flat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE FLAT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.9440000000000004D0 :Y 0.6919998035430917D0 :W 0.26 :H 0.1 :BOX-STRING "nth-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PATCH-WORK::NTH-RANDOM)) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 20 :VALUE-STRING "20") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.33599999999999986D0 :Y 0.5959998035430911D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(3 1 3 3 3 3 3 3 2 3 3 1 3 2 3 3 3 3 2 3)" :CONNECTION NIL)) :X 1.2840000014901154D0 :Y 1.2279999985098833D0 :W 0.9440000119209291D0 :H 0.12400000149011614D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.9440000119209291D0 :OPEN-STATE-H 0.12400000149011614D0 :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(2 1 1 3 2 2 2 3 1 3 3 3 2 2 3 3 2 3 3 3)" :CONNECTION NIL)) :X 1.380000002980232D0 :Y 1.443999997019767D0 :W 0.9440000119209291D0 :H 0.12400000149011614D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.9440000119209291D0 :OPEN-STATE-H 0.12400000149011614D0 :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 1.448D0 :Y 1.7039999427795412D0 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "n" :CURVAL 20 :VALUE-STRING "20") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "weight-list" :CURVAL (LIST 1 10 2 20 3 70) :VALUE-STRING "(1 10 2 20 3 70)")) :X 1.2279999999999998D0 :Y 1.939999942779541D0 :W 0.5399999809265137D0 :H 0.10000000149011612D0 :BOX-STRING "weighted-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :X-PROPORTIONS (LIST (LIST 0.27999999266404285D0 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::WEIGHTED-RANDOM) :OPEN-STATE-W 0.5399999809265137D0 :OPEN-STATE-H 0.10000000149011612D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "n" :CURVAL 20 :VALUE-STRING "20") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "weight-list" :CURVAL (LIST 1 20.5 2 51 3 77.7) :VALUE-STRING "(1 20.5 2 51 3 77.7)")) :X 1.8200000014901159D0 :Y 1.9359999412894254D0 :W 0.6679999809265138D0 :H 0.10400000149011657D0 :BOX-STRING "weighted-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :X-PROPORTIONS (LIST (LIST 0.27999999266404285D0 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::WEIGHTED-RANDOM) :OPEN-STATE-W 0.6679999809265138D0 :OPEN-STATE-H 0.10400000149011657D0) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 2) (1 1) (2 1) (3 3) (4 2) (5 2) (6 2) (7 3) (8 1) (9 3) (10 3) (11 3) (12 2) (13 2) (14 3) (15 3) (16 2) (17 3) (18 3) (19 3))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.57 :GLORTHOX2 19.57 :GLORTHOY1 0.94 :GLORTHOY2 3.06)) :X 457 :Y 345 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 457 :Y 345 :WIDTH 350 :HEIGHT 350))) WIN) :CONNECTION NIL)) :X 1.4560000000000013D0 :Y 0.6999997367858888D0 :W 1.2959999999999999D0 :H 0.492D0 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR) :OPEN-STATE-W 1.2959999999999999D0 :OPEN-STATE-H 0.492D0) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 1.7080000014901167D0 :Y 0.9639999412894249D0 :Z -0.1 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH) :INPUT-DRAW-MODE :PW-DOUBLE-INPUTS :CURRENT-INPUT-NUMBER 1)) :X 5 :Y 5 :SCALEFX 0.5 :SCALEFY 0.5 :TRANSLY -0.07599995374679555D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 17 :OUT-BOX 0 :PWBOX2 16 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.032999998155981425D0 :DY -0.2094001001194119D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.435999998584391D0 :Y 0.8039999411404133D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 17 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.3227499987483031D0 :DY 0.4109999717995527D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.757500004947186D0 :Y 1.0639999979138369D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 17 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.12825000360608074D0 :DY -0.1510000274553891D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.8515000017285353D0 :Y 1.2799999964237206D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2592499958574772D0 :DY -0.05499999884516016D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5915000002384186D0 :Y 1.7919999406933785D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.013750006496906387D0 :DY -0.056999999590217954D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.4975000034570694D0 :Y 1.7999999421834945D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.10299999960884465D0 :DY -0.09839997171610637D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3600000015646217D0 :Y 1.5439999426305296D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.029000005159526943D0 :DY -0.12139990075677676D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.264000000074505D0 :Y 0.4559998029470447D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.3699999932013449D0 :DY -0.04139999824017315D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8759999823421238D0 :Y 0.5519998029470452D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.09600000203028314D0 :DY -0.03740009646862763D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9239999985843901D0 :Y 0.6439999994039543D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.020000006262212988D0 :DY -0.09739999227970842D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.5799999985843902D0 :Y 0.8199999879300597D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.1060000062622124D0 :DY -0.12340000420063713D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8619999786466361D0 :Y 0.9799999998509885D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 1 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.2686666653193528D0 :DY -0.15060000487417002D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.5799999985843889D0 :Y 1.2504000131189828D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.5928333236537868D0 :DY -0.15060000487417002D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1399999823421232D0 :Y 1.2504000131189828D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3279999979697168D0 :DY -0.09939999824017276D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.1679999985843903D0 :Y 1.6279999994039538D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.18400000203028322D0 :DY 0.003800005599856382D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7809999998509887D0 :Y 1.3609999997392297D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3099999979697168D0 :DY -0.05139999730885014D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.79599999858439D0 :Y 1.435999999403954D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1660000020302832D0 :DY -0.0073999982401729D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.48399999858439014D0 :Y 1.6279999994039538D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.30199999488890184D0 :Y 1.2504000131189828D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.15399999666586517D0 :DY -0.25939999824017246D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.33199999858439045D0 :Y 1.723999999403953D0 :DX 0.0 :DY 0.0))) :WINDOW-DOCUMENTATION "ab-lisp
© Achim Bornhoeft
A list of weighted random numbers." :X 0 :Y 23 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 22,398 | Common Lisp | .l | 16 | 1,395.125 | 20,742 | 0.747486 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 18cb9ea329afad73f036bdd4d6132219d6dfb4ba63addd0b7d27bbf12d43c761 | 35,190 | [
-1
] |
35,191 | 02-percentage.pwgl | bornhoeft_ab-lisp/tutorial/Math/02-percentage.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(in-package :cl-user)
(defun percentage (p h)
\"How much percent is p from h?\"
(* h (/ p 100)))
;; (percentage 10 80)
(defun percentage? (n h)
\"How much is n in percent from h?\"
(* 100 (/ n h)))
;; (percentage? 20 80)
(defun hundred-percent? (n p)
\"What is hundred percent when n is p percent ?\"
(* 100 (/ n p)))
;; (hundred-percent? 20 10)
")) :X 2.012D0 :Y 1.5560000000000005D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :CURVAL 20 :VALUE-STRING "20") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 80 :VALUE-STRING "80")) :X 0.968D0 :Y 1.2319999999999998D0 :W 0.52 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 100.0 :VALUE-STRING "100.0")) :X 1.2480000000000003D0 :Y 0.996D0 :W 0.52 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "12.5" :CONNECTION NIL)) :X 1.528D0 :Y 0.7999999999999998D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "percentage?" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :CURVAL 20 :VALUE-STRING "20") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 10 :VALUE-STRING "10")) :X 1.8120000014901159D0 :Y 1.2319999985098838D0 :W 0.52 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 100.0 :VALUE-STRING "100.0")) :X 2.092000001490116D0 :Y 0.995999998509884D0 :W 0.52 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "200.0" :CONNECTION NIL)) :X 2.372000001490116D0 :Y 0.7999999985098838D0 :W 0.3840000119209286D0 :H 0.10800000149011613D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :X-PROPORTIONS (LIST (LIST 1)) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "hundred-percent?" :OPEN-STATE-W 0.3840000119209286D0 :OPEN-STATE-H 0.10800000149011613D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :CURVAL 10 :VALUE-STRING "10") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 100 :VALUE-STRING "100")) :X 0.1760000014901162D0 :Y 1.2279999985098838D0 :W 0.52 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 80 :VALUE-STRING "80")) :X 0.45600000149011644D0 :Y 0.991999998509884D0 :W 0.52 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "8" :CONNECTION NIL)) :X 0.7360000014901162D0 :Y 0.7959999985098838D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "percentage" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T))) :X 5 :Y 5 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.022999995585530897D0 :DY -0.16139999824017304D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.4360000000745061D0 :Y 1.0879999979138373D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.03100000441446893D0 :DY -0.17539999824017283D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.7160000000745059D0 :Y 0.8519999979138375D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.022999995585530897D0 :DY -0.16139999824017304D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.072000000074506D0 :Y 1.0919999979138373D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.03100000441446893D0 :DY -0.17539999824017283D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.3520000000745056D0 :Y 0.8559999979138375D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.03100000441446893D0 :DY -0.17539999824017283D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5079999985843898D0 :Y 0.8559999994039536D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.022999995585530897D0 :DY -0.16139999824017304D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.22799999858439D0 :Y 1.0919999994039534D0 :DX 0.0 :DY 0.0))) :X 481 :Y 267 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 9,663 | Common Lisp | .l | 17 | 566.470588 | 8,788 | 0.737399 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 3fd2d2393b271a96fab91d4e43aa1b78617f3465de35ab25ad29f3b8dcb2d5c1 | 35,191 | [
-1
] |
35,192 | 01-golden-section.pwgl | bornhoeft_ab-lisp/tutorial/Math/01-golden-section.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-342)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 342)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 873 :Y 389 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(in-package :cl-user)
(defun golden-number ()
(/ (+ 1 (sqrt 5)) 2))
;; (golden-number)
(defun golden-section (s &key (part NIL))
(let ((gn (/ (+ 1 (sqrt 5)) 2)))
(case part
('major (/ s gn))
('minor (- s (/ s gn)))
(otherwise (* s gn)))))
;; (golden-section 1) => 1.618034
;; (golden-section 1 :part 'major) => 0.618034
;; (golden-section 1 :part 'minor) => 0.381966
")) :X 1.56D0 :Y 1.9200000000000004D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX) :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "a" :CURVAL 5 :VALUE-STRING "5")) :X 0.6880000000000015D0 :Y 2.0000003910064695D0 :W 0.26 :H 0.1 :BOX-STRING "sqrt" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE SQRT)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :CURVAL 1 :VALUE-STRING "1") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.2760000000000007D0 :Y 1.8440003910064693D0 :W 0.52 :H 0.1 :BOX-STRING "g+" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G+)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 2 :VALUE-STRING "2")) :X 0.5560000000000005D0 :Y 1.6600003910064696D0 :W 0.52 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "1.618034" :CONNECTION NIL)) :X 0.8359999999999999D0 :Y 1.4680000000000009D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "golden number" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 1.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-NUMBOX-SUBVIEW) :BOX-STRING "num" :CURVAL 2 :VALUE-STRING "2")) :X 0.2519999999999998D0 :Y 1.4400000000000004D0 :W 0.26 :H 0.1 :BOX-STRING "num-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE NUM-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.0439999999999992D0 :Y 1.164000000000001D0 :W 0.52 :H 0.1 :BOX-STRING "g*" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G*)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :CURVAL 1 :VALUE-STRING "1" :CONNECTION NIL)) :X 0.4040000000000008D0 :Y 0.9279999999999995D0 :W 0.52 :H 0.1 :BOX-STRING "g/" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G/)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l1?" :VALUE-STRING "0" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "l2?" :VALUE-STRING "0" :CONNECTION NIL)) :X 0.12399999999999922D0 :Y 0.6960000000000002D0 :W 0.52 :H 0.1 :BOX-STRING "g-" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G-)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "3.236068" :CONNECTION NIL)) :X 1.1360000014901157D0 :Y 0.9239999985098844D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "golden section" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "1.236068" :CONNECTION NIL)) :X 0.964000002980232D0 :Y 0.6999999970197677D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "golden section (major)" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :R 0.5181 :G 0.6081 :B 0.6081 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "0.763932" :CONNECTION NIL)) :X 0.40400000447034757D0 :Y 0.47999999552965145D0 :W 0.3 :H 0.1 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :USER-STRING "golden section (minor)" :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "s" :CURVAL 3 :VALUE-STRING "3") (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "keyarg" :STEPVAL 0.2 :MINVAL 0 :MAXVAL 0 :MENU-LIST (LIST ":part") :MENU-LIST-STRING ":part") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "&key" :CURVAL (LIST (QUOTE QUOTE) (QUOTE COMMON-LISP-USER::MINOR)) :VALUE-STRING "'minor")) :X 1.5360000000000005D0 :Y 1.8120002326965339D0 :W 0.49599999046325705D0 :H 0.1775999882221222D0 :BOX-STRING "golden-section" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 2) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 3 :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::GOLDEN-SECTION) :OPEN-STATE-W 0.49599999046325705D0 :OPEN-STATE-H 0.1775999882221222D0 :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-COMMENT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-COMMENT-BOX-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "optional arguments not working in PWGL")) :X 1.54D0 :Y 1.5520002326965332D0 :W 1.032000001490116D0 :H 0.09200000149011611D0 :BOX-STRING "1" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE PWGL-COMMENT-BOX) :OPEN-STATE-W 1.032000001490116D0 :OPEN-STATE-H 0.09200000149011611D0 :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "function" :CURVAL "+" :VALUE-STRING "+") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sequence" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 1.871999999999999D0 :Y 0.5160004844665531D0 :W 0.52 :H 0.1 :BOX-STRING "reduce" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 2) :EXTENSION-LIMIT 12 :BORDER 0.012) :PW-FUNCTION (QUOTE REDUCE)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.7479999999999998D0 :Y 0.800000099182129D0 :W 0.26 :H 0.17359999 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PWGL-COMMENT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-COMMENT-BOX-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "2.0" :CONNECTION NIL)) :X 2.1519999999999997D0 :Y 0.324000099182129D0 :W 0.14400000149011616D0 :H 0.10400000149011612D0 :BOX-STRING "1" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE PWGL-COMMENT-BOX) :OPEN-STATE-W 0.14400000149011616D0 :OPEN-STATE-H 0.10400000149011612D0 :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1))) :X 5 :Y 5 :SCALEFX 0.5 :SCALEFY 0.5 :TRANSLY -0.09200014781951882D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 16 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.0789999955855305D0 :DY -0.08558019039034859D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.1319999985843894D0 :Y 0.3560004843175415D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 14 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.2619999932013448D0 :DY -0.07059981223195777D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.411999982342123D0 :Y 0.5664001123011113D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 15 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.5919999944306913D0 :DY 0.18980005742609518D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7129999998509882D0 :Y 0.30499999571591596D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 15 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.31199999517574906D0 :DY 0.1166000537723304D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.7279999985843895D0 :Y 0.5399999968707561D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.36100000664964305D0 :DY -0.03340000047534719D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.38400000305473725D0 :Y 0.5559999994039537D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.07700000590458456D0 :DY -0.08739999973028856D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9440000015646217D0 :Y 0.787999999403953D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.08899999484047272D0 :DY -0.0853999989852312D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1160000000745054D0 :Y 1.0239999994039546D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 7 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.045000004414469386D0 :DY -0.10539999824017255D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6639999823421232D0 :Y 0.787999999403953D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 8 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.15199999796971686D0 :DY -0.46139999824017286D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.10399999858438891D0 :Y 1.299999999403954D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.4259999878369276D0 :DY -0.16939999824017305D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9439999823421248D0 :Y 1.3079999998509893D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.16399999796971643D0 :DY -0.2653999982401729D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.3839999985843905D0 :Y 1.299999999403954D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.13799999320134515D0 :DY -0.12539999824017278D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5839999823421232D0 :Y 1.299999999403954D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1879999966658652D0 :DY -0.02939999824017292D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0239999985843889D0 :Y 1.3079999998509893D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.004999995585531103D0 :DY -0.1314001937434075D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8159999985843895D0 :Y 1.5200003904104232D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.04200000679865479D0 :DY -0.06339999824017273D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8159999823421247D0 :Y 1.860000390410423D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.05699999558553115D0 :DY -0.07539999824017274D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.5359999985843902D0 :Y 1.7040003904104229D0 :DX 0.0 :DY 0.0))) :WINDOW-DOCUMENTATION "© 2015
Achim Bornhoeft
Golden Section" :X 5 :Y 23 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 19,923 | Common Lisp | .l | 19 | 1,045.894737 | 18,879 | 0.746357 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | e3a2f759ca9fd3cb7cdd708ffa4b8231ba7a6f69aa1d67b1bd31aa63c8de37ba | 35,192 | [
-1
] |
35,193 | reciproc.pwgl | bornhoeft_ab-lisp/tutorial/Math/reciproc.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-331)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 331)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "RECIPROC" :X 5 :X 5 :WIDTH 730 :HEIGHT 530) :VALUE-STRING "(in-package :cl-user)
(defun reciproc (x)
(/ 1 x))
;;; (reciproc 0.25)")) :X 1.3719999999999999D0 :Y 0.6319999999999997D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL (LIST (QUOTE COMMON-LISP-USER::|1_8|)) :VALUE-STRING "(1_8)")) :X 0.5960000000000001D0 :Y 1.6799999999999998D0 :W 0.26 :H 0.1 :BOX-STRING "value-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE VALUE-BOX)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lists" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.8479999999999999D0 :Y 1.2680000000000007D0 :W 0.325 :H 0.17359999 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT)) (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.6299999963045115D0 :Y 0.5279999880790713D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "x" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 1.04D0 :Y 0.7120000000000002D0 :W 0.26 :H 0.1 :BOX-STRING "reciproc" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE COMMON-LISP-USER::RECIPROC)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "sequence" :CURVAL "(0 1)" :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.472D0 :Y 1.2999999999999999D0 :W 0.26 :H 0.1 :BOX-STRING "reverse" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE REVERSE)) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 0.9199999999999999D0 :Y 0.956D0 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH))) :X 5 :Y 5 :TRANSLY -0.1919999134540558D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.029000001098960615D0 :DY -0.08539999824017275D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0199999985843898D0 :Y 0.7959999998509884D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 1 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.08541666579246532D0 :DY -0.05820000622421517D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0635000002384185D0 :Y 1.034400013118983D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.09258333456516277D0 :DY -0.05820000622421517D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9695000034570693D0 :Y 1.034400013118983D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 5 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.26599999796971696D0 :DY -0.1181999944001435D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8129999998509883D0 :Y 1.1449999997392295D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.20000000203028323D0 :DY -0.05339999824017272D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.45199999858438966D0 :Y 1.5399999994039533D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.007000008646399047D0 :DY -0.13140000420063713D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.1699999786466356D0 :Y 0.5719999994039537D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.026000002030283076D0 :DY -0.17739999730885003D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8279999985843896D0 :Y 1.5399999994039533D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6099999948889012D0 :Y 1.034400013118983D0 :DX 0.0 :DY 0.0))) :X 5 :Y 22 :WIDTH 530 :HEIGHT 476))) (WINDOW-SELECT WIN) WIN) | 8,391 | Common Lisp | .l | 7 | 1,197.285714 | 7,831 | 0.749135 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | e0a6ec7dfdcba5d479efdafc9539270f4b0a0b4e2e4d020dc929fb59c8aef2a7 | 35,193 | [
-1
] |
35,194 | 99-test.pwgl | bornhoeft_ab-lisp/tutorial/Math/99-test.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 18 (0.9.18-201)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 18) 201)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :TITLE "TITEL" :X 5 :X 5 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 279 | Common Lisp | .l | 4 | 69 | 124 | 0.695652 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | ff569be9e29cc9bb101f73f8e0a99af25e473d9996bf41ffac0fee06ca63a723 | 35,194 | [
-1
] |
35,195 | reflect.pwgl | bornhoeft_ab-lisp/tutorial/Lists/reflect.pwgl | (IN-PACKAGE :CCL)
;; this patch was saved with PWGL version 1.0 beta RC 19 (0.9.19-342)
(ASSERT-PATCH-SAVED-VERSION-NOT-NEWER-THAN (QUOTE ((0 9 19) 342)))
(LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-PW-WINDOW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-LISP-CODE-BOX) :R 1.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :R 1.0 :G 1.0 :B 1.0 :BOX-STRING "auto-evaluate" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 757 :Y 233 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(in-package :cl-user)
(defun reflect (hi lo values)
(loop for i in values
with x = (abs (- hi lo))
for y = (mod i x)
collect
(if (evenp (floor (/ i x))) y (- x y)) into reslis
finally (return (mapcar #'(lambda (x) (+ x lo)) reslis))))
; (reflect 5 -1 '(-5 9 6 2 -4 -5 0 6 9 -5 -3 -5 9 -10 0 2 7 4 5 -2 2))
")) :X 2.604D0 :Y 1.3639999999999995D0 :W 0.11 :H 0.015 :BOX-STRING "(Lisp)" :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.0084) :PW-FUNCTION (QUOTE LISP-CODE-BOX) :FORMAT-ARGS (LIST :PRINT-ESCAPE T :COLUMNS 1)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "value" :CURVAL (LIST (QUOTE COMMON-LISP-USER::|-10_10|)) :VALUE-STRING "(-10_10)")) :X 0.5000000000000004D0 :Y 2.052D0 :W 0.26 :H 0.1 :BOX-STRING "value-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE VALUE-BOX)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP-BUFFER) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "list" :CURVAL (LIST 0 1) :VALUE-STRING "(0 1)" :CONNECTION NIL)) :X 0.7000000000000002D0 :Y 1.3319999999999994D0 :W 0.325 :H 0.1 :BOX-STRING "pwgl-enum" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-ENUM)) (MAKE-INSTANCE (QUOTE PW-BOX-MAP) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "enum" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 0.4619999963045127D0 :Y 0.8039999880790698D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-map" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 5 :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-MAP)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10)" :CONNECTION NIL)) :X 0.3640000000000003D0 :Y 1.6159999999999997D0 :W 1.3240000119209295D0 :H 0.1280000014901157D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 1.3240000119209295D0 :OPEN-STATE-H 0.1280000014901157D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-TEXT-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-TEXT-SUBVIEW) :BOX-STRING "text" :APPLICATION-WINDOW (MAKE-INSTANCE (QUOTE PWGL-FRED-WINDOW) :TITLE "Text-Editor" :X 100 :Y 100 :WIDTH 500 :HEIGHT 600) :VALUE-STRING "(0 1 2 3 4 5 4 3 2 1 0 1 2 3 4 5 4 3 2 1 0)" :CONNECTION NIL)) :X 0.15200000149011528D0 :Y 0.5359999985098831D0 :W 0.9800000119209287D0 :H 0.11600000149011614D0 :BOX-STRING "text-box" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE TEXT-BOX) :OPEN-STATE-W 0.9800000119209287D0 :OPEN-STATE-H 0.11600000149011614D0 :EXTRA-PARENTHESIS? NIL :FORMAT-ARGS (LIST :FORMAT T :COLUMNS 1 :PRINT-ESCAPE T)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "argument" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "args" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.4D0 :Y 0.6999999999999993D0 :W 0.26 :H 0.17359999 :BOX-STRING "list" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE LIST) :CURRENT-EXTENSION-PATTERN-INDEX* 1) (MAKE-INSTANCE (QUOTE 2D-EDITOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-SUBBOX) :APPLICATION-WINDOW (LET ((WIN (MAKE-INSTANCE (QUOTE PWGL-FUNCTION-EDITOR-WINDOW) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-2D-VIEW) :R 1.0 :G 1.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 -10) (1 -9) (2 -8) (3 -7) (4 -6) (5 -5) (6 -4) (7 -3) (8 -2) (9 -1) (10 0) (11 1) (12 2) (13 3) (14 4) (15 5) (16 6) (17 7) (18 8) (19 9) (20 10)))) (MAKE-INSTANCE (QUOTE C-BREAK-POINT-FUNCTION) :POINTS (QUOTE ((0 2) (1 3) (2 4) (3 5) (4 4) (5 3) (6 2) (7 1) (8 0) (9 -1) (10 -2) (11 -1) (12 0) (13 1) (14 2) (15 3) (16 4) (17 5) (18 4) (19 3) (20 2))))) :Y 1.0 :W 1.0 :H 1.0 :GLORTHOX1 -0.59999997 :GLORTHOX2 20.6 :GLORTHOY1 -10.6 :GLORTHOY2 10.6)) :X 441 :Y 247 :HITS 1 :WINDOW-UPDATE? T :TITLE "2D-Editor1" :X 441 :Y 247 :WIDTH 514 :HEIGHT 359))) WIN) :CONNECTION NIL)) :X 2.1160000000000015D0 :Y 0.7639999999999994D0 :W 0.6839999999999997D0 :H 0.5800000000000001D0 :BOX-STRING "2D-Editor" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "objects") (MAKE-INSTANCE (QUOTE PWGL-OUTPUT) :BOX-STRING "active")) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1) :ORIG-GROUPING-LIST (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE 2D-EDITOR) :OPEN-STATE-W 0.6839999999999997D0 :OPEN-STATE-H 0.5800000000000001D0) (MAKE-INSTANCE (QUOTE PWGL-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "low" :CURVAL -10 :VALUE-STRING "-10") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "high" :CURVAL 10 :VALUE-STRING "10")) :X 1.7600000000000003D0 :Y 2.076D0 :W 0.52 :H 0.1 :BOX-STRING "g-random" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE G-RANDOM)) (MAKE-INSTANCE (QUOTE PW-REPEAT) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "count" :CURVAL 21 :VALUE-STRING "21") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :VALUE-STRING "0" :CONNECTION NIL)) :X 1.1520000000000002D0 :Y 1.984D0 :W 0.52 :H 0.1 :BOX-STRING "pwgl-repeat" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-REPEAT)) (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :R 0.0 :G 0.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "x" :CURVAL 11 :VALUE-STRING "11" :CONNECTION NIL :ARG-NAME (QUOTE X) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "n" :CURVAL 5 :VALUE-STRING "5" :ARG-NAME (QUOTE N) :ARG-TYPE :VAR)) :X 0.8720000000000008D0 :Y 1.0839999999999997D0 :W 0.26 :H 0.2 :BOX-STRING "zigzag" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :TEXT "(let ((y (mod x n)))
(if (evenp (floor (/ x n))) y (- n y)))") (MAKE-INSTANCE (QUOTE PWGL-CODE-BOX) :R 0.0 :G 0.0 :B 1.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "hi" :CURVAL 5 :VALUE-STRING "5" :ARG-NAME (QUOTE HI) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "lo" :CURVAL -2 :VALUE-STRING "-2" :ARG-NAME (QUOTE LO) :ARG-TYPE :VAR) (MAKE-INSTANCE (QUOTE PWGL-FREE-VALUE-BOX-SUBVIEW) :BOX-STRING "values" :CONNECTION NIL :ARG-NAME (QUOTE VALUES) :ARG-TYPE :VAR)) :X 1.6240000014901175D0 :Y 1.2799999985098829D0 :W 0.26 :H 0.3 :BOX-STRING "reflect" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1 1) :ORIG-GROUPING-LIST (LIST 1 1 1) :BORDER 0.012) :PW-FUNCTION (QUOTE CODE-BOX) :TEXT "(iter (for i in values)
(with x = (abs (- hi lo)))
(for y = (mod i x))
(collect
(if (evenp (floor (/ i x))) y (- x y)) into reslis)
(finally (return (pw::g+ lo reslis))))") (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 0.9040000000000008D0 :Y 1.8040000572204589D0 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH)) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-INPUT-SELECTOR-SUBVIEW) :CONNECTION NIL)) :X 1.7880000014901159D0 :Y 0.9000000557303425D0 :W 0.2 :H 0.1 :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2) :ORIG-GROUPING-LIST (LIST 2) :EXTENSION-PATTERN (LIST 1) :BORDER 0.012) :PW-FUNCTION (QUOTE PWGL-SWITCH)) (MAKE-INSTANCE (QUOTE PWGL-BOX) :R 0.0 :G 0.0 :B 0.0 :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "hi" :CURVAL 5 :VALUE-STRING "5") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "lo" :CURVAL -2 :VALUE-STRING "-2") (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "values" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL)) :X 2.028D0 :Y 1.4720000076293949D0 :W 0.52 :H 0.16 :BOX-STRING "reflect" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 2 1) :ORIG-GROUPING-LIST (LIST 2 1) :BORDER 0.012) :PW-FUNCTION (QUOTE AB-LISP::REFLECT)) (MAKE-INSTANCE (QUOTE CONST-VALUE-BOX) :PWGL-SUBVIEWS (LIST (MAKE-INSTANCE (QUOTE PWGL-VALUE-BOX-SUBVIEW) :BOX-STRING "patch" :CURVAL "()" :VALUE-STRING "()" :CONNECTION NIL) (MAKE-INSTANCE (QUOTE PWGL-MENUBOX-SUBVIEW) :BOX-STRING "loopmode" :CURVAL 2 :STEPVAL 0.2 :MINVAL 0 :MAXVAL 2 :MENU-LIST :CONST-VALUE-MBOX-LIST :MENU-LIST-STRING ":eachtime")) :X 1.12D0 :Y 1.4080000076293926D0 :W 0.32 :H 0.17359999 :BOX-STRING "const-value" :PWGL-OUTPUTS (LIST (MAKE-INSTANCE (QUOTE PWGL-OUTPUT))) :BOX-LAYOUT (MAKE-INSTANCE (QUOTE PWGL-BOX-LAYOUT) :GROUPING-LIST (LIST 1 1) :ORIG-GROUPING-LIST (LIST 1) :EXTENSION-PATTERN (LIST 1) :EXTENSION-LIMIT 2 :BORDER 0.012) :PW-FUNCTION (QUOTE CONST-VALUE) :CURRENT-EXTENSION-PATTERN-INDEX* 1)) :X 5 :Y 5 :SCALEFX 0.5 :SCALEFY 0.5 :TRANSLY -0.09200005793571466D0 :CONNECTIONS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 14 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.3210000014342367D0 :DY -0.06309999747574269D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.4889999998509884D0 :Y 1.2074000210836507D0 :DX -0.504D0 :DY 0.0479999999999996D0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 11 :INPUT-BOX 2 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1110000021792954D0 :DY -0.07100001735240191D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.5890000013411059D0 :Y 1.159400021083651D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 13 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.2630000018440186D0 :DY -0.12120002286136145D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3649999998509883D0 :Y 0.725000055916607D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 15 :OUT-BOX 0 :PWBOX2 6 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.05900000143423689D0 :DY -0.26740000112354756D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.3799999985843896D0 :Y 1.174400020748375D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 15 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.02199999666586472D0 :DY -0.08139999442547597D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0999999985843898D0 :Y 1.4479999994039537D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 14 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.29049998709559444D0 :DY -0.16899997807294165D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.9315000017285345D0 :Y 1.2720000120997433D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 10 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.16099999135360132D0 :DY -0.11940000345557977D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0019999786466367D0 :Y 0.8439999979138371D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 11 :OUT-BOX 0 :PWBOX2 13 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.11550000393390603D0 :DY -0.008999965764582285D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.8375000049471853D0 :Y 0.9399999874830236D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 9 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3484999878406523D0 :DY 0.021000029020011413D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.0475000002384194D0 :Y 1.8439999994039536D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 12 :OUT-BOX 0 :PWBOX2 4 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3230000010989609D0 :DY -0.08940002744644882D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.34399999858439D0 :Y 1.6440000570714473D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 1 :OUT-BOX 0 :PWBOX2 12 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.23150000393390657D0 :DY -0.08099997097998846D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.9535000034570702D0 :Y 1.9119999994039536D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 10 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.1662499973736702D0 :DY -0.14269999822229118D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.8519999985843905D0 :Y 1.1719999998509878D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 8 :OUT-BOX 0 :PWBOX2 9 :INPUT-BOX 1 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.4969999955855309D0 :DY 0.00460000175982711D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 1.6919999823421242D0 :Y 1.9359999994039537D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 6 :OUT-BOX 0 :PWBOX2 7 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.1260000020302836D0 :DY 0.07339999363571415D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 2.095999998584391D0 :Y 0.4664000131189816D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 3 :OUT-BOX 0 :PWBOX2 5 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3119999929927295D0 :DY -0.05639999302476628D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.13200000007450497D0 :Y 0.6439999879300582D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 4 :OUT-BOX 0 :PWBOX2 2 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX -0.3160000033341346D0 :DY -0.10539999824017277D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.6799999985843899D0 :Y 1.4479999994039537D0 :DX 0.0 :DY 0.0)) (MAKE-INSTANCE (QUOTE PWGL-CONNECTION) :PWBOX1 2 :OUT-BOX 0 :PWBOX2 3 :INPUT-BOX 0 :DRAW-MODE :5POINT :BEZIER-SELECTOR1 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 1) :BEZIER-SELECTOR2 (MAKE-INSTANCE (QUOTE PWGL-BEZIER-SELECTOR) :POINT-NUM 2) :CONNECTION-POINTS (LIST (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :DX 0.004750000778585672D0 :DY -0.11540000420063734D0)) :CONNECTION-POINT (MAKE-INSTANCE (QUOTE PWGL-CONNECTION-POINT-SELECTOR) :X 0.4419999948889024D0 :Y 1.1719999998509878D0 :DX 0.0 :DY 0.0))) :WINDOW-DOCUMENTATION "AB-LISP
© Achim Bornhoeft
Reflection of values into a specified range." :X 5 :Y 23 :WIDTH 730 :HEIGHT 530))) (WINDOW-SELECT WIN) WIN) | 20,776 | Common Lisp | .l | 21 | 985.619048 | 11,533 | 0.73688 | bornhoeft/ab-lisp | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | c6c6a709aaa9273754b8b2078242ea06ff71bf96d254e0332ab7210c40b381f9 | 35,195 | [
-1
] |
35,210 | lcc.lisp | conao3_clcc_lisp/tests/lcc.lisp | (defpackage lcc-test
(:use :cl
:lcc
:prove))
(in-package :lcc-test)
;; NOTE: To run this test file, execute `(asdf:test-system :lcc)' in your Lisp.
(plan nil)
;; blah blah blah.
(finalize)
| 211 | Common Lisp | .lisp | 9 | 20 | 79 | 0.646465 | conao3/clcc.lisp | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | f5b635a943f0a4c8c5a06e774d59ef59a529029721e5523eb269df2b8356f501 | 35,210 | [
-1
] |
35,211 | lcc.asd | conao3_clcc_lisp/lcc.asd | #|
This file is a part of lcc project.
Copyright (c) 2018 Naoya Yamashita
|#
#|
Author: Naoya Yamashita
|#
(defsystem "lcc"
:version "0.1.0"
:author "Naoya Yamashita"
:license "MIT"
:depends-on ()
:components ((:module "src"
:components
((:file "lcc"))))
:description ""
:long-description
#.(read-file-string
(subpathname *load-pathname* "README.markdown"))
:in-order-to ((test-op (test-op "lcc-test"))))
| 468 | Common Lisp | .asd | 20 | 19.25 | 53 | 0.621076 | conao3/clcc.lisp | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 6e45269b551f1a36b3d6c8369c704be751357012559cc661cb1f142e32b1b3be | 35,211 | [
-1
] |
35,212 | lcc-test.asd | conao3_clcc_lisp/lcc-test.asd | #|
This file is a part of lcc project.
Copyright (c) 2018 Naoya Yamashita
|#
(defsystem "lcc-test"
:defsystem-depends-on ("prove-asdf")
:author "Naoya Yamashita"
:license "MIT"
:depends-on ("lcc"
"prove")
:components ((:module "tests"
:components
((:test-file "lcc"))))
:description "Test system for lcc"
:perform (test-op (op c) (symbol-call :prove-asdf :run-test-system c)))
| 444 | Common Lisp | .asd | 15 | 24.133333 | 73 | 0.615925 | conao3/clcc.lisp | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 3a1ae27a41244766c83a94edfc03ec4f437eff7ccc5ed76b0effcdf32199b9fc | 35,212 | [
-1
] |
35,229 | lat.lisp | shepherdjerred-homework_lat-function/lat.lisp | (defun lat? (x)
(if (listp x)
(if (= (list-length x) '0)
't
(if (atom (first x))
(lat? (cdr x))
'nil
)
)
'nil
)
)
; (LAT? '(A B C))
; (LAT? '())
; (LAT? 'A)
; (LAT? '(A (B C) D))
| 231 | Common Lisp | .lisp | 16 | 10.1875 | 30 | 0.361502 | shepherdjerred-homework/lat-function | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 96d27d77fd0e5347bb39e79b2e67a2b1f8231f353cf3df38336172fcb1ebfc70 | 35,229 | [
-1
] |
35,246 | util.lisp | petelliott_peterci/db/util.lisp | (defpackage :peterci.db.util
(:nicknames :db.util)
(:use cl)
(:export
#:convert-repo-record
#:convert-build-record
#:db-oneshot
#:itostat
#:stattoi
#:btoi
#:itob
#:plist-set))
(in-package :peterci.db.util)
(defun convert-repo-record (record)
(if record
(plist-set record :|active| (itob (getf record :|active|)))))
(defun convert-build-record (record)
(if record
(plist-set record :|status| (itostat (getf record :|status|)))))
(defun db-oneshot (conn qstr &rest vals)
"prepares then executes a query with vals as args"
(apply #'dbi:execute
(dbi:prepare conn qstr) vals))
(defun itostat (i)
"converts an int to a build status"
(elt #(:running :stopped :passed :failed) i))
(defun stattoi (stat)
"converts a build status to an int"
(getf '(:running 0 :stopped 1 :passed 2 :failed 3) stat))
(defun btoi (bool)
"converts a bool to an int"
(if bool 1 0))
(defun itob (i)
"converts an int to a bool"
(if (zerop i) nil t))
(defun plist-set (plist key val)
"creates a new plist with the value of
key set to val. appends the entry if the
key does not exist in the original list"
(if plist
(if (eq key (car plist))
(mcons key val (cddr plist))
(mcons (car plist) (cadr plist)
(plist-set (cddr plist) key val)))
(list key val)))
(defun mcons (&rest args)
"conses the first n args with the last one"
(if (null (cdr args))
(car args)
(cons
(car args)
(apply #'mcons (cdr args)))))
| 1,532 | Common Lisp | .lisp | 52 | 25.326923 | 68 | 0.653662 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | b296bd35c6991a07b65fd9cfb594935830129c09a8da56894291cff4b4e2d2f4 | 35,246 | [
-1
] |
35,247 | repo.lisp | petelliott_peterci/db/repo.lisp | (defpackage :peterci.db.repo
(:nicknames :db.repo)
(:use :cl :peterci.db.util)
(:export
#:create
#:get-repo
#:set-active
#:get-by-info
#:get-status
#:get-builds))
(in-package :peterci.db.repo)
(defun create (conn provider usr repo &optional (active t))
"creates a repo with the given paramaters, an returns it's id"
(dbi:with-transaction conn
(db-oneshot conn
"INSERT INTO Repo
(provider, username, repo, active)
VALUES (?, ?, ?, ?)"
provider usr repo (btoi active))
(getf (dbi:fetch
(db-oneshot conn "SELECT LAST_INSERT_ID()"))
:|LAST_INSERT_ID()|)))
(defun get-repo (conn id)
"get the repo associated with id"
(convert-repo-record
(dbi:fetch
(db-oneshot conn
"SELECT * FROM Repo WHERE id=?"
id))))
(defun set-active (conn repo &optional (active t))
"sets the repo to active or not"
(dbi:do-sql conn
"UPDATE Repo SET active=? WHERE id=?"
(db.util:btoi active) repo))
(defun get-by-info (conn provider usr repo)
"get the repo associated with the provider, usr, and repo"
(convert-repo-record
(dbi:fetch
(db-oneshot conn
"SELECT * FROM Repo WHERE
provider=? AND username=? AND repo=?"
provider usr repo))))
(defun get-status (conn id &optional (branch "master"))
"get the repo's build status"
(let ((res (getf
(dbi:fetch (db-oneshot
conn
"SELECT status FROM Build
WHERE repo=? AND (status=2 OR status=3)
AND branch=?
ORDER BY id DESC"
id branch))
:|status|)))
(if res
(itostat res)
res)))
(defun get-builds (conn id &optional branch)
"get the builds of a repo, if branch is specified,
get only those of branch"
(if branch
(get-builds-branch conn id branch)
(get-builds-all conn id)))
(defun get-builds-all (conn id)
"get the repo's builds"
(mapcar #'convert-build-record
(dbi:fetch-all
(db-oneshot
conn
"SELECT * FROM Build
WHERE repo=? ORDER BY id DESC"
id))))
(defun get-builds-branch (conn id branch)
"get the repo's builds on branch"
(mapcar #'convert-build-record
(dbi:fetch-all
(db-oneshot
conn
"SELECT * FROM Build
WHERE repo=? AND branch=?
ORDER BY id DESC"
id branch))))
| 2,692 | Common Lisp | .lisp | 81 | 23.432099 | 67 | 0.545314 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | aa5f4827924ccaeb53cbf90efaf4a596d83f77eec1660f5e4e700b01f175c156 | 35,247 | [
-1
] |
35,248 | build.lisp | petelliott_peterci/db/build.lisp | (defpackage :peterci.db.build
(:nicknames :db.build)
(:use :cl :peterci.db.util)
(:export
#:create
#:update
#:get-build))
(in-package :peterci.db.build)
(defun create (conn repo hash branch &optional (status :running) logs)
(dbi:with-transaction conn
(db-oneshot conn
"INSERT INTO Build
(repo, status, logs, branch, hash)
VALUES (?, ?, ?, ?, ?)"
repo (stattoi status) logs
branch hash)
(getf (dbi:fetch
(db-oneshot conn "SELECT LAST_INSERT_ID()"))
:|LAST_INSERT_ID()|)))
(defun update (conn id status &optional logs)
"update the build associated with ID
status: one of :running :stopped :passed :failed
logs: string of logs (left the same if null)"
(dbi:with-transaction conn
(update-build-status conn id status)
(if logs
(update-build-logs conn id logs))))
(defun update-build-status (conn id status)
"update status of build ID to one of
:running :stopped :passed :failed"
(db-oneshot conn
"UPDATE Build SET status=? WHERE id=?"
(stattoi status) id))
(defun update-build-logs (conn id logs)
"set the logs for build ID"
(db-oneshot conn
"UPDATE Build SET logs=? WHERE id=?"
logs id))
(defun get-build (conn id)
"get the build associated with ID"
(convert-build-record
(dbi:fetch
(db-oneshot conn
"SELECT * FROM Build
WHERE id=?"
id))))
| 1,534 | Common Lisp | .lisp | 46 | 25.869565 | 70 | 0.602981 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | b34e8f43c9dba319fcc31b95aa4bc969ab60ea808d53cbb40b4c8a093c321de4 | 35,248 | [
-1
] |
35,249 | github.lisp | petelliott_peterci/repo/github.lisp | (defpackage :peterci.repo.github
(:nicknames github-driver)
(:use :cl :peterci.repo :peterci.util))
(in-package :peterci.repo.github)
(defstruct gh-repo
username
repo)
(defun make-gh-repo-call (username repo)
(make-gh-repo :username username
:repo repo))
(register-service "github" #'make-gh-repo-call)
(defmethod get-tarball ((repo gh-repo) refspec &optional strm)
(let ((tar-strm
(dex:get
(pmerge "https://api.github.com/repos"
(gh-repo-username repo)
(gh-repo-repo repo)
"tarball" refspec)
:want-stream t
:force-binary t)))
(if strm
(stream-pipe tar-strm strm)
tar-strm)))
| 738 | Common Lisp | .lisp | 23 | 24.217391 | 62 | 0.598303 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | d0f6a1ed38d5a9d7d9d48f9d3e71be976bf0a4fe829f8c4da230f652ab44bfbf | 35,249 | [
-1
] |
35,250 | repo.lisp | petelliott_peterci/repo/repo.lisp | ;;; generic methods for repo access
(defpackage :peterci.repo
(:nicknames :ci-repo)
(:use :cl)
(:export
#:get-tarball
#:register-service
#:make-repo))
(in-package :peterci.repo)
;; downloads a tarball of the repo and returns a strem
;; unless strm is set, in which case it writes to strm
(defgeneric get-tarball (repo refspec &optional strm))
(defvar *repo-hash* (make-hash-table :test #'equal))
(defun register-service (provider creat-fun)
"registers a service provider with a function
that takes a username and repo and returns
an object with the neccesary generics defined"
(setf (gethash provider *repo-hash*) creat-fun))
(defun make-repo (provider usr repo)
"create a repo with the given characteristics"
(funcall
(gethash provider *repo-hash*)
usr repo))
| 810 | Common Lisp | .lisp | 23 | 32.086957 | 54 | 0.737789 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 359f55d5c24888af2db55cae5515526e1584e540629a88fc42bb509e6028deb3 | 35,250 | [
-1
] |
35,251 | api.lisp | petelliott_peterci/api/api.lisp | (defpackage :peterci.api
(:nicknames :api)
(:use :cl)
(:export
#:*app*
#:*conn*
#:*config*
#:start
#:stop))
(in-package :peterci.api)
(defvar *app* (make-instance 'ningle:<app>))
(defvar *conn*)
(defvar *config*)
(defvar def-config '(:clack ()
:db (:mysql
:database-name "peterci"
:username "root")
:gh-key #P"/home/peter/tokens/peterci-dev.2018-09-04.private-key.pem"))
;; TODO: these functions are buggy as fuck
(defun start (&optional (config def-config))
(let* ((*config* config)
(*conn* (apply #'dbi:connect
(getf *config* :db))))
(list
:clack (apply #'clack:clackup *app* (getf *config* :clack))
:db-conn *conn*)))
(defun stop (handler)
(clack:stop (getf handler :clack))
(dbi:disconnect (getf handler :db-conn)))
| 916 | Common Lisp | .lisp | 29 | 23.931034 | 92 | 0.550228 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 4dca69524bc4a9f7d466dd69e0116b16d97dd4805652ef392f11db45ddb05e85 | 35,251 | [
-1
] |
35,252 | util.lisp | petelliott_peterci/api/util.lisp | (defpackage :peterci.api.util
(:nicknames :api.util)
(:use :cl)
(:export
#:headers
#:nf-on-nil
#:status
#:truthy
#:url-to-repo))
(in-package :peterci.api.util)
(defun headers (&rest headers)
(setf (lack.response:response-headers ningle:*response*)
(append (lack.response:response-headers ningle:*response*)
headers)))
(defun nf-on-nil (form)
(if (null form)
(setf (lack.response:response-status ningle:*response*) 404))
form)
(defun status (status)
(setf (lack.response:response-status ningle:*response*) status))
(defun truthy (val)
(cdr (assoc
val
'((t . t)
("true" . t)
(1 . t))
:test #'equal)))
(defun url-to-repo (conn params)
"convert provider/user/repo in url to a repo id"
(getf (db.repo:get-by-info
conn
(cdr (assoc :provider params))
(cdr (assoc :user params))
(cdr (assoc :repo params)))
:|id|))
| 983 | Common Lisp | .lisp | 35 | 22.057143 | 66 | 0.599787 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 6368d6a88fa258dd8e2e805d71b411a1622227cfd7ce1f2dbd30527ed9e94eb3 | 35,252 | [
-1
] |
35,253 | github.lisp | petelliott_peterci/api/github.lisp | (defpackage :peterci.api.github
(:nicknames api.gh)
(:use :cl))
(in-package :peterci.api.github)
(setf (ningle:route api:*app* "/hooks/github/authorize" :method :POST)
(lambda (params)
(print params)
(print #\newline)))
(setf (ningle:route api:*app* "/hooks/github" :method :POST)
(lambda (params)
(print params)
(print #\newline)))
(defun unix-time ()
(- (get-universal-time)
(encode-universal-time 0 0 0 1 1 1970 0)))
(defun get-jwt-token (id pemfile)
"gets a jwt for github with id"
(jose/jwt:encode
:RS256
(pem:read-from-file pemfile)
`(("iat" . ,(unix-time))
("exp" . ,(+ (unix-time) (* 10 60)))
("iss" . ,id))))
| 710 | Common Lisp | .lisp | 23 | 25.869565 | 70 | 0.60472 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 5a6c2ccf219386c818097ac02cad9ffafe129b3fe1ee2788f764713ab4be8d58 | 35,253 | [
-1
] |
35,254 | repo.lisp | petelliott_peterci/api/repo.lisp | (defpackage :peterci.api.repo
(:nicknames :api.repo)
(:use :cl))
(in-package :peterci.api.repo)
(setf (ningle:route api:*app* "/repo/:repo" :method :GET)
(lambda (params)
(api.util:headers :content-type "application/json")
(json:encode-json-to-string
(putil:plist-to-alist
(api.util:nf-on-nil
(db.repo:get-repo api:*conn* (cdr (assoc :repo params))))))))
(setf (ningle:route api:*app* "/repo/:provider/:user/:repo" :method :GET)
(lambda (params)
(api.util:headers :content-type "application/json")
(json:encode-json-to-string
(api.util:nf-on-nil
(putil:plist-to-alist
(db.repo:get-by-info api:*conn*
(cdr (assoc :provider params))
(cdr (assoc :user params))
(cdr (assoc :repo params))))))))
(defun set-active (conn repo active)
(api.util:status 204)
(db.repo:set-active conn
repo
(api.util:truthy active)))
(setf (ningle:route api:*app* "/repo/:repo/active" :method :POST)
(lambda (params)
(set-active api:*conn*
(cdr (assoc :repo params))
(cdr (assoc "active" params :test #'string=)))))
(setf (ningle:route api:*app* "/repo/:provider/:user/:repo/active" :method :POST)
(lambda (params)
(let ((id (api.util:url-to-repo api:*conn* params)))
(set-active api:*conn*
id
(cdr (assoc "active" params :test #'string=))))))
(defun status-image (repo &optional (branch "master"))
"redirect to a status badge for the repo and branch"
(api.util:status 303)
(let ((res (db.repo:get-status api:*conn* repo branch)))
(api.util:headers :location
(format nil
"https://img.shields.io/badge/peterci-~A-~A.svg"
(getf '(:passed "passing"
:failed "failing"
nil "unknown") res)
(getf '(:passed "brightgreen"
:failed "red"
nil "yellow") res))))
"you should be redirected to an image")
(setf (ningle:route api:*app* "/statusimage/:repo" :method :GET)
(lambda (params)
(status-image (cdr (assoc :repo params)))))
(setf (ningle:route api:*app* "/statusimage/:repo/:branch" :method :GET)
(lambda (params)
(status-image (cdr (assoc :repo params))
(cdr (assoc :branch params)))))
(setf (ningle:route api:*app* "/statusimage/:provider/:user/:repo" :method :GET)
(lambda (params)
(let ((rid (api.util:url-to-repo api:*conn* params)))
(status-image rid))))
(setf (ningle:route api:*app* "/statusimage/:provider/:user/:repo/:branch" :method :GET)
(lambda (params)
(let ((rid (api.util:url-to-repo api:*conn* params)))
(status-image rid
(cdr (assoc :branch params))))))
| 3,151 | Common Lisp | .lisp | 67 | 33.880597 | 88 | 0.527914 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | ddf06446ee10a5c7fb789330a64e85ea796722261b30fbc3990d092f2668bba0 | 35,254 | [
-1
] |
35,255 | builder.lisp | petelliott_peterci/builder/builder.lisp | (defpackage :peterci.builder
(:use :cl)
(:nicknames :builder)
(:export
#:build
#:sql-build))
(in-package :peterci.builder)
(defun build (ar-file &optional (image "peterci-env"))
"build the repo in ar-file and return the
build status and the logs"
(docker:with-container con image
(docker:container-put-archive con ar-file)
(docker:container-start con)
(values
(zerop (docker:container-wait con))
(docker:container-get-logs con))))
(defun sql-build (conn repoid branch ref)
"builds the branch repoid and creates an sql build
this function is designed to be run as it's own thread"
(let* ((res (db.repo:get-repo conn repoid))
(path (fad:with-output-to-temporary-file
(strm :element-type '(unsigned-byte 8))
(ci-repo:get-tarball
(res-to-repo res)
ref strm)))
(buildid (db.build:create conn repoid ref branch)))
(multiple-value-bind (status logs)
(build path)
(db.build:update
conn buildid
(if status :passed :failed)
logs))))
(defun res-to-repo (res)
(ci-repo:make-repo
(getf res :|provider|)
(getf res :|username|)
(getf res :|repo|)))
| 1,240 | Common Lisp | .lisp | 37 | 26.945946 | 60 | 0.632636 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 7d0b700e06d9d897d33a9def1e8fd5a93ac0cc93c5b6f47541cd4477cfcedb62 | 35,255 | [
-1
] |
35,256 | docker.lisp | petelliott_peterci/builder/docker.lisp | (defpackage :peterci.builder.docker
(:use :cl :peterci.util)
(:nicknames :docker)
(:export
#:*docker-uri*
#:with-container
#:container-create
#:container-wait
#:container-start
#:container-stop
#:container-delete
#:container-put-archive
#:container-get-logs))
(in-package :peterci.builder.docker)
;; *docker-uri* is the uri that docker requests will
;; be made to. this variable can also be used to set
;; api version.
(defvar *docker-uri* "http://localhost:2735/")
(defmacro with-container (container image &rest forms)
"provides a temporary container that will be
deleted after the block ends"
`(let ((,container (container-create ,image)))
(multiple-value-prog1
(progn ,@forms)
(container-delete ,container))))
(defun container-create (image)
"create a docker container from an image and
return it's ID"
(cdr
(assoc
:*id
(json-post
(dpath "/containers/create")
`(("Image" . ,image))))))
(defun container-wait (container)
"wait for a container to finish and return it's
exit status"
(cdr
(assoc
:*Status-Code
(json-post
(dpath "containers" container "wait")))))
(defun container-start (container)
"start a given container"
(dex:post
(dpath "containers" container "start")))
(defun container-stop (container)
"stop a given container"
(dex:post
(dpath "containers" container "stop")))
(defun container-delete (container)
"delete a given container"
(dex:delete
(dpath "containers" container)))
(defun container-put-archive (container ar-path)
"upload an archive to a given container"
(dex:put
(dpath "containers" container "archive?path=/repo")
:headers '(("Content-Type" . "application/x-tar"))
:content (pathname ar-path)))
(defun container-get-logs (container)
"get the stdout and stderr logs of a given
container as a string"
(parse-log-stream
(dex:get
(dpath "containers" container "logs?stdout=1&stderr=1"))))
(defun parse-log-stream (vec)
"strip the 8-byte header from a docker log and
convert it to a string"
(setf vec (subseq vec 8))
(with-output-to-string (strm)
(dotimes (i (length vec))
(write-char (code-char (elt vec i)) strm)
(if (= (elt vec i) (char-code #\newline))
(incf i 8)))))
(defun dpath (&rest paths)
"merge the given paths with the *docker-uri*"
(apply #'pmerge (cons *docker-uri* paths)))
| 2,472 | Common Lisp | .lisp | 78 | 27.397436 | 64 | 0.680878 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | e52b455ca3fc57df89e1df6ee8e79699e8e38da05bd0fc3b42ac511952167dc2 | 35,256 | [
-1
] |
35,257 | util.lisp | petelliott_peterci/util/util.lisp | ;;; utilities for peterci
(defpackage :peterci.util
(:nicknames :putil)
(:use :cl)
(:export
#:plist-to-alist
#:stream-pipe
#:pmerge
#:starts-with
#:ends-with
#:json-post
#:json-get))
(in-package :peterci.util)
(defun plist-to-alist (plist)
(if plist
(cons
(cons (first plist) (second plist))
(plist-to-alist (cddr plist)))))
(defun stream-pipe (in-stream out-stream)
"copies a byte stream from in-stream to
out-stream"
(loop
(let ((ch (read-byte in-stream nil)))
(if (null ch)
(return)
(write-byte ch out-stream)))))
(defun pmerge (&rest paths)
"merge pathnames
('a' 'b') -> 'a/b'
('a/' '/b') -> 'a/b'"
(cond
((= (length paths) 0) "")
((= (length paths) 1) (car paths))
(t
(concatenate
'string
(if (ends-with (car paths) "/")
(car paths)
(concatenate 'string (car paths) "/"))
(let ((prest (apply #'pmerge (cdr paths))))
(if (starts-with prest "/")
(subseq prest 1)
prest))))))
(defun starts-with (whole start)
"check if sequence whole starts with sequence
start. t if whole == start also"
(and
(<= (length start) (length whole))
(equal (subseq whole 0 (length start)) start)))
(defun ends-with (whole end)
"check if sequence whole ends with sequence
end. t if whole == end also"
(and
(<= (length end) (length whole))
(equal (subseq whole (- (length whole) (length end))) end)))
(defun json-post (uri &optional data)
"post a cl-json lisp object data to uri and
then return the cl-json encoded result"
(json:decode-json-from-string
(dex:post
uri
:headers '(("Content-Type" . "application/json"))
:content (if data
(json:encode-json-to-string data)
nil))))
(defun json-get (uri)
"get from url and return the cl-json encoded
result"
(json:decode-json-from-string
(dex:get uri)))
| 1,988 | Common Lisp | .lisp | 70 | 22.971429 | 64 | 0.598003 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 09aa152cf930454b23b05a7d159aa52e54d59cc6c3d85fca61c090c9e8ad73c4 | 35,257 | [
-1
] |
35,258 | peterci.builder.asd | petelliott_peterci/peterci.builder.asd |
(defpackage :peterci.builder-asd
(:use :cl :asdf))
(in-package :peterci.builder-asd)
(defsystem peterci.builder
:depends-on (:cl-json
:dexador
:peterci.util
:peterci.db
:peterci.repo
:cl-fad)
:components ((:module "builder"
:components
((:file "docker")
(:file "builder")))))
| 411 | Common Lisp | .asd | 14 | 18.714286 | 38 | 0.502551 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 4a1b1f31f296ffe4421ae814fb822adeaafb9ba6081db4e7cb835313ff94a3df | 35,258 | [
-1
] |
35,259 | peterci.api.asd | petelliott_peterci/peterci.api.asd |
(defpackage :peterci.api-asd
(:use :cl :asdf))
(in-package :peterci.api-asd)
(defsystem peterci.api
:depends-on (:ningle
:cl-dbi
:clack
:jose
:pem
:peterci.builder
:peterci.db
:peterci.repo
:peterci.util)
:components ((:module "api"
:components
((:file "util")
(:file "api")
(:file "repo")
(:file "github")))))
| 525 | Common Lisp | .asd | 19 | 15.368421 | 37 | 0.423154 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 8218daf4a7f3de2908c5ec6b8539ada29237eb5fa8c3a610f372b9d5a7c058f1 | 35,259 | [
-1
] |
35,260 | peterci.db.asd | petelliott_peterci/peterci.db.asd |
(defpackage :peterci.db-asd
(:use :cl :asdf))
(in-package :peterci.db-asd)
(defsystem peterci.db
:depends-on (:cl-dbi)
:components ((:module "db"
:components
((:file "util")
(:file "repo")
(:file "build")))))
| 286 | Common Lisp | .asd | 10 | 19.9 | 36 | 0.505535 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 263f4b8598996ab6dead7e9bc5c328c412fdc0185c781aedee9d70ccc3eea151 | 35,260 | [
-1
] |
35,261 | peterci.util.asd | petelliott_peterci/peterci.util.asd |
(defpackage :peterci.util-asd
(:use :cl :asdf))
(in-package :peterci.util-asd)
(defsystem peterci.util
:depends-on (:cl-json
:dexador)
:components ((:module "util"
:components
((:file "util")))))
| 255 | Common Lisp | .asd | 9 | 20.777778 | 35 | 0.566667 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 48c9817af85917ab7c5ffa76f8ac110ac198bdf42636f7660c35e74c8bb9c528 | 35,261 | [
-1
] |
35,262 | peterci.repo.asd | petelliott_peterci/peterci.repo.asd |
(defpackage :peterci.repo-asd
(:use :cl :asdf))
(in-package :peterci.repo-asd)
(defsystem peterci.repo
:depends-on (:cl-json
:dexador
:peterci.util)
:components ((:module "repo"
:components
((:file "repo")
(:file "github")))))
| 318 | Common Lisp | .asd | 11 | 19.636364 | 37 | 0.521595 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 1ff79af4871b4c3e0327caf02e5bef6239493fe0d2dac8e0ada137661e601844 | 35,262 | [
-1
] |
35,268 | schema.sql | petelliott_peterci/db/schema.sql | CREATE TABLE Repo (
id INT NOT NULL AUTO_INCREMENT,
provider varchar(255) NOT NULL,
username varchar(255) NOT NULL,
repo varchar(255) NOT NULL,
active boolean DEFAULT true,
PRIMARY KEY (id)
-- UNIQUE (provider, username, repo) (too long to be a key)
);
CREATE TABLE Build (
id int NOT NULL AUTO_INCREMENT,
repo int NOT NULL,
status TINYINT DEFAULT 0,
time DATETIME DEFAULT CURRENT_TIMESTAMP,
logs TEXT,
branch varchar(255) NOT NULL,
hash char(40) NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY (repo) REFERENCES Repo(id)
);
| 579 | Common Lisp | .l | 20 | 24.9 | 60 | 0.697133 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | fbc6bb3fd0bb45cb56beaf71ba947c85ad096cb0d8072fe7dc90c4554d5ddf1f | 35,268 | [
-1
] |
35,272 | build.sh | petelliott_peterci/docker/build.sh | #!/bin/bash
cd $1
runlines() {
while read line; do
echo '$' $line
$line
if [ $? != 0 ]
then
echo -e "\e[31m'$line' failed\e[0m\n"
exit $1 # status
fi
echo -e "\e[32m'$line' passed\e[0m\n"
done
}
exit_nz() {
if [ $1 != 0 ]
then
exit $1
fi
}
jq ".dep | .[]" -r < peterci.json | runlines 3
exit_nz $?
jq ".script | .[]" -r < peterci.json | runlines 1
exit_nz $?
| 471 | Common Lisp | .l | 24 | 13.958333 | 49 | 0.466667 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | 89e35539922d4bcc9000d65ef587bcdaca30709e3fc5ff0cbb4b788505123f8f | 35,272 | [
-1
] |
35,273 | Dockerfile | petelliott_peterci/docker/Dockerfile | FROM ubuntu:18.04
COPY build.sh /
RUN mkdir /repo
RUN apt-get update && apt-get install -y jq
CMD ./build.sh /repo/*
| 121 | Common Lisp | .l | 5 | 22.4 | 43 | 0.732143 | petelliott/peterci | 0 | 0 | 3 | AGPL-3.0 | 9/19/2024, 11:44:00 AM (Europe/Amsterdam) | cc0cde6c5f34b3e5d1e617165d23ef90b9abfd361bc56da4bf2c2b04e0083f7e | 35,273 | [
-1
] |
35,295 | lookup.lisp | shepherdjerred-homework_lookup-function/src/lookup.lisp | ; Jerred Shepherd
(defun lookup (k m)
(if (listp m)
(if (listp (first m))
(if (eq k (first (first m)))
(second (first m))
(if (endp (rest m))
nil
(lookup k (rest m))
)
)
nil
)
nil
)
)
; (lookup 'a '((a b) (c d))) ; => b
; (lookup 'e '((a b) (c d))) ; => nil
; (lookup 'a '((b a) (c d))) ; => nil
; (lookup 'e '((a b) (c d) (e f))) ; => f
; (lookup 'c '((a b) (c (d e f)))) ; => (d e f)
| 563 | Common Lisp | .lisp | 21 | 18.238095 | 47 | 0.32963 | shepherdjerred-homework/lookup-function | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | 551368575a2249002f264dc8aa634da86fd5028d95c248d7f9c4f48b4a44005a | 35,295 | [
-1
] |
35,312 | myreverse.lisp | shepherdjerred-homework_myreverse/src/myreverse.lisp | ; Jerred Shepherd
(defun myreverse (list)
(if (null list)
()
(append (myreverse (cdr list)) (if (listp (first list))
(list (myreverse (first list)))
(list (first list))))
)
)
; (myreverse '(a b c)) ; => (c b a)
; (myreverse '(a (b c) d)) ; => (d (c b) a)
| 375 | Common Lisp | .lisp | 11 | 22.545455 | 75 | 0.406077 | shepherdjerred-homework/myreverse | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | 62ae25e05c590a4506ba67f216d254daf2faaf130832fa41d7ddfb7a6a3f3867 | 35,312 | [
-1
] |
35,329 | match.lisp | shepherdjerred-homework_match-function/src/match.lisp | ; match
; Jerred Shepherd
; predicate: a symbol
; returns: T if predicate is a pattern variable (u, v, w, x, y, z), NIL otherwise
(defun is-pattern (predicate)
(if
(member predicate '(u v w x y z))
t
nil))
; l: an S-Expression
; r: an S-Expression
; returns: T if both l and r are NULL, NIL otherwise
(defun both-null (l r)
(and (null l) (null r)))
; l: an S-Expression
; r: an S-Expression
; returns: T if either l or r are NULL, NIL otherwise
(defun either-null (l r)
(or (null l) (null r)))
; l: an S-Expression
; r: an S-Expression
; returns: T if either l or r are and atom, NIL otherwise
(defun either-atom (l r)
(or (atom l) (atom r)))
; sub: a list of lists which contain pattern variables
; pattern: a variable to check for
; returns: T if sub contains pattern, NIL otherwise
(defun is-pattern-conflict (sub pattern value)
(if
(null sub)
nil
(if
(eq (caar sub) pattern)
(if
(eq (cdr (car sub)) value)
(is-pattern-conflict (cdr sub) pattern value)
t)
(is-pattern-conflict (cdr sub) pattern value))))
(defun is-pattern-used (sub pattern value)
(if
(null sub)
nil
(if
(eq (caar sub) pattern)
t
(is-pattern-used (cdr sub) pattern value))))
; term: a list to match
; pattern: a pattern list
; sub: substituions that can be applied to pattern to make it identical to the term
; returns: (NIL) if term and pattern already match, NIL if term and pattern cannot match, a list of substitutions that can be applied to the pattern to make it identical to the substitution
(defun match-recur (term pattern sub)
(if
(both-null term pattern)
sub
(if
(either-null term pattern)
nil
(if
(either-atom term pattern)
nil
(if
(eq (car term) (car pattern))
(match-recur (cdr term) (cdr pattern) sub)
(if
(is-pattern (car pattern))
(if
(is-pattern-conflict sub (car pattern) (car term))
nil
(if
(is-pattern-used sub (car pattern) (car term))
(match-recur (cdr term) (cdr pattern) sub)
(if
(null (car sub))
(match-recur (cdr term) (cdr pattern) (list (cons (car pattern) (car term))))
(match-recur (cdr term) (cdr pattern) (append sub (list (cons (car pattern) (car term))))))))
(let
(
(matched-list (match-recur (car term) (car pattern) sub)))
(if
(null matched-list)
nil
(match-recur (cdr term) (cdr pattern) matched-list)))))))))
(defun match (term pattern)
(match-recur term pattern '(nil)))
; Test cases
; (and
; (and
; (equal (is-pattern-conflict '((X . A)) 'X 'A) nil))
; (and
; (equal (is-pattern 'x) t)
; (equal (is-pattern 'a) nil))
; (and
; (equal (both-null 'nil 'nil) t)
; (equal (both-null 'a 'nil) nil)
; (equal (both-null 'a 'b) nil))
; (and
; (equal (either-null 'nil 'nil) t)
; (equal (either-null 'a 'nil) t)
; (equal (either-null 'a 'b) nil))
; (and
; (equal (match 'a 'b) nil)
; (equal (match '(+ a b) '(+ y z)) '((y . a) (z . b)))
; (equal (match '(+ a b) '(+ a x)) '((x . b)))
; (equal (match '(* a b) '(* a b)) '(nil))
; (equal (match '(f a b) '(f a a)) nil)
; (equal (match '(+ a b) '(- a b)) nil)
; (equal (match '(+ (- b c) a) '(+ x y)) '((x - b c) (y . a)))
; (equal (match '(loves a b) '(loves x x)) nil)
; (equal (match '(loves joe pie) '(loves x pie)) '((x . joe)))
; (equal (match '(+ a (+ b a)) '(+ x (+ y x))) '((x . a) (y . b)))))
| 5,545 | Common Lisp | .lisp | 110 | 30.772727 | 189 | 0.370869 | shepherdjerred-homework/match-function | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | d191017637df380d6a5d6f53baa0bb89115b2d0be8a53006fca9b5bdf0891f28 | 35,329 | [
-1
] |
35,346 | myreplace.lisp | shepherdjerred-homework_myreplace/src/myreplace.lisp | ; Jerred Shepherd
(defun myreplace (old new target)
(if (null target) nil
(if (listp target)
(let ((curr (first target)))
(if (listp curr)
(append (list (myreplace old new curr)) (myreplace old new (cdr target)))
(if (eq curr old)
(append (list new) (myreplace old new (cdr target)))
(append (list curr) (myreplace old new (cdr target)))
)
)
)
(if (eq target old)
new
target
)
)
)
)
; (myreplace 'name 'joe '(name is my favorite name)) ; => (joe is my favorite joe)
; (myreplace 'name 'joe 'name) ; => joe
; (myreplace 'name 'joe nil) ; => nil
; (myreplace 'name 'joe '(name (name is name) name)) ; => (joe (joe is a joe) joe
| 838 | Common Lisp | .lisp | 24 | 27.041667 | 86 | 0.500617 | shepherdjerred-homework/myreplace | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | bd0ebf0c98bc14a5b46eb234c0c507e4e1fae5d4853143f73e90d8797e05a8b7 | 35,346 | [
-1
] |
35,363 | main.lisp | sgbasaraner_logical-hero/main.lisp | (load "logic.lisp")
(loop (let ((expression (make-random-expression)) (solution-or-not (random 2)))
(write-line expression)
(write-line (if (equal solution-or-not 0) (solve-expression expression) (make-wrong-answer expression)))
(let ((answer (read-line)))
(cond
((equal answer (string "t"))
(write-line (if (equal solution-or-not 0) (string "Correct answer!") (string "Wrong answer!"))))
((equal answer (string "f"))
(write-line (if (equal solution-or-not 1) (string "Correct answer!") (string "Wrong answer!"))))
(t (write-line (string "Please use t or f."))))))) | 631 | Common Lisp | .lisp | 11 | 50.454545 | 108 | 0.624194 | sgbasaraner/logical-hero | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | dcc211f3ba87120f542f8d327bc1d9cc2b24e196f952876e3e9ba6f2da16cd3e | 35,363 | [
-1
] |
35,364 | logic.lisp | sgbasaraner_logical-hero/logic.lisp | ;;; parameters for convenience
(defparameter *and* (string "∧")
"Logical AND operator.")
(defparameter *or* (string "∨")
"Logical OR operator.")
(defparameter *true* (string "T")
"Logical TRUE.")
(defparameter *false* (string "F")
"Logical FALSE.")
;;; random generators
(defun should-negate-p ()
(equal (random 4) 0))
(defun should-add-parantheses-p ()
(equal (random 4) 0))
(defun make-random-item ()
(string (char "TFp" (random 3))))
(defun make-random-operator ()
(string (char "∧∨" (random 2))))
(defun make-random-block ()
(if (should-negate-p)
(string "¬p")
(make-random-item)))
(defun make-random-expression ()
(if (should-add-parantheses-p)
(concatenate 'string "¬(" (make-random-block) " " (make-random-operator) " " (make-random-block) ")")
(concatenate 'string (make-random-block) " " (make-random-operator) " " (make-random-block))))
;;; expression solving
(defun has-parantheses-p (expr)
(equal (subseq expr 0 2) (string "¬(")))
(defun remove-parantheses (expr)
(subseq expr 2 (- (length expr) 1)))
(defun get-operator (expr)
(or (find #\∧ expr :test #'equal)
(find #\∨ expr :test #'equal)))
(defun get-left (expr)
(string-trim " " (subseq expr 0 2)))
(defun get-right (expr)
(let ((len (length expr)))
(string-trim " " (subseq expr (- len 2) len))))
(defun truep (block)
(equal block *true*))
(defun falsep (block)
(equal block *false*))
(defun both-true-p (expr)
(let ((left (get-left expr)) (right (get-right expr)))
(and (truep left) (truep right))))
(defun both-false-p (expr)
(let ((left (get-left expr)) (right (get-right expr)))
(and (falsep left) (falsep right))))
(defun andp (operator)
(equal (string operator) *and*))
(defun orp (operator)
(equal (string operator) *or*))
;; returns the other part of the expression if one part is true,
;; doesn't check the other part if first part is true
(defun one-true (expr)
(let ((left (get-left expr)) (right (get-right expr)))
(cond ((truep left) right)
((truep right) left)
(t nil))))
;; false version of one-true
(defun one-false (expr)
(let ((left (get-left expr)) (right (get-right expr)))
(cond ((falsep left) right)
((falsep right) left)
(t nil))))
(defun negate-block (block)
(cond
((equal block *false*) *true*)
((equal block *true*) *false*)
((equal (subseq block 0 1) (string "¬")) (string "p"))
(t (concatenate 'string "¬" block))))
(defun solve-without-parantheses (expr)
(let ((operator (get-operator expr)))
(cond
((both-true-p expr) *true*)
((both-false-p expr) *false*)
((and (one-true expr) (orp operator)) *true*)
((and (one-true expr) (andp operator)) (one-true expr))
((and (one-false expr) (orp operator)) (one-false expr))
((and (one-false expr) (andp operator)) *false*)
((equal (get-left expr) (get-right expr)) (get-left expr))
((orp operator) *true*)
(t *false*))))
(defun solve-expression (expr)
(if (has-parantheses-p expr)
(negate-block (solve-without-parantheses (remove-parantheses expr)))
(solve-without-parantheses expr)))
;; generates a wrong but not completely unbelievable answer
(defun make-wrong-answer (expr)
(let ((solution (solve-expression expr)))
(cond
((equal solution (string "¬p")) (make-random-item))
((equal solution (string "p")) (negate-block (make-random-item)))
((find #\p expr :test #'equal) (nth (random 3)
(remove-if (lambda (str) (equal str solution)) '("p" "T" "F" "¬p"))))
(t (negate-block solution))))) | 3,623 | Common Lisp | .lisp | 97 | 33.340206 | 105 | 0.637565 | sgbasaraner/logical-hero | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | db4c3c730824eadbd52d25d471889961d341fca739659919a706303f5c33b803 | 35,364 | [
-1
] |
35,382 | run-tests.lisp | yangby_template-commonlisp-project/run-tests.lisp | #|
Copyright (C) 2018 YangBy <[email protected]>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
|#
(ql:quickload "fiveam" :silent t)
(ql:quickload "uiop" :silent t)
(ql:quickload "asdf" :silent t)
(push (uiop:getcwd) asdf:*central-registry*)
(ql:quickload "fibonacci-test")
(let ((results (5am:run 'fibonacci-test:fibonacci-suite)))
(5am:explain! results)
(uiop:quit (if (eq (5am:results-status results) t) 0 1)))
| 1,006 | Common Lisp | .lisp | 21 | 46.428571 | 75 | 0.776302 | yangby/template-commonlisp-project | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | c40eb76d62c0523c45e259799d8c02d1734d234b3dff334e7504215a13e51643 | 35,382 | [
-1
] |
35,383 | package.lisp | yangby_template-commonlisp-project/src/package.lisp | #|
Copyright (C) 2018 YangBy <[email protected]>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
|#
(defpackage fibonacci
(:nicknames :fib)
(:use :cl)
(:export :fibonacci))
| 764 | Common Lisp | .lisp | 17 | 43.352941 | 75 | 0.791386 | yangby/template-commonlisp-project | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | 5e2388e1a29e46189528aa6fefe5acd1594f849bbd6d4698e9fc1c05fb9e5e3c | 35,383 | [
-1
] |
35,384 | fibonacci.lisp | yangby_template-commonlisp-project/src/fibonacci.lisp | #|
Copyright (C) 2018 YangBy <[email protected]>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
|#
(in-package :fibonacci)
(defun fibonacci(n)
(check-type n (integer 0 *))
(if (< n 2) n
(+ (fibonacci (- n 1)) (fibonacci (- n 2)))))
| 829 | Common Lisp | .lisp | 18 | 44.222222 | 75 | 0.763027 | yangby/template-commonlisp-project | 0 | 0 | 0 | AGPL-3.0 | 9/19/2024, 11:44:08 AM (Europe/Amsterdam) | ac892f35aa1dafab24362751d72da2ea1b9533076daf5c0bbc26caa20c793824 | 35,384 | [
-1
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.