— Function: ARRAY-FOR-EACH FUNC &REST ARRAYS

Calls func on all element tuples of the array arguments.

— Function: BLACKBOARD &REST ITEMS

Make the property list supplied in items into a blackboard. Copies items to make sure that no literal list is modified.

— Class: BLACKBOARD

A blackboard where data items can be put and extracted using the function GETBB.

Direct slots:

• ITEMS: A property list of items on the blackboard.

— Function: BOX OBJECT

Boxes an object.

— Class: CACHE-DICTIONARY

This is a dictionary which can only hold a certain number of items. If more are inserted, only the most recently accessed items are kept.

Direct slots:

• SIZE: Self-explanatory.
• TEST: Self-explanatory.
• STORE: Self-explanatory.
• ITEM-STORE: Self-explanatory.

— Function: CHECK-PROPERTIES PLACE PROPERTIES

Checks if all of the properties are in the property list place.

— Function: COMMON-LISP-SPEED &KEY (CACHE 0.5) (MEMORY 0.5)

Returns the speed which should be characteristic for the setting determined by the keyword arguments.

— Function: COMPOSE &REST FUNCTIONS

Returns the composition of functions.

— Function: COMPOSE-2 F G

Composes two function objects f and g.

— Function: CONCEPT-DOCUMENTATION DOCSTRING

Documents a certain concept.

— Function: CONSTANT-VECTOR DIM VALUE

Returns a uniform constant vector of which all elements are value.

— Function: COPY-HASH-TABLE HASH-TABLE

Copy hash-table.

— Function: COPY-SLOTS OBJ1 OBJ2 SLOTS

Initializes the slots named in slots from obj2 to obj1. Returns obj1.

— Function: CURRY FUNC &REST ARGS

Supplies args to func from the left.

— Function: DEQUEUE QUEUE

Pops an object from queue. Returns as second value T if the queue was empty.

— Function: DEQUEUE-ALL QUEUE

Clears queue and returns content as a list.

— Function: DIC-EMPTY-P DICTIONARY

Tests if dictionary is empty.

— Function: DIC-FOR-EACH FUNCTION DICTIONARY

Applies function to each key-value pair in dictionary.

— Function: DIC-FOR-EACH-KEY FUNCTION DICTIONARY

Applies function to each key in dictionary.

— Function: DIC-FOR-EACH-VALUE FUNCTION DICTIONARY

Applies function to each value in dictionary.

— Function: DIC-REF DICTIONARY KEY

Returns the value of the entry for key in dictionary.

— Function: DIC-REMOVE KEY DICTIONARY

Removes key from dictionary.

— Function: DISPLAY-HT HASH-TABLE

Display hash-table in the form key1 -> value1 ...

— Function: DLL-FRONT-INSERT OBJ DLL &OPTIONAL INSERT-ITEM-P

Inserts obj in dll. It returns the newly created dll-item.

— Function: DLL-REAR-INSERT OBJ DLL &OPTIONAL INSERT-ITEM-P

Inserts obj in dll. It returns the newly created dll-item.

— Macro: DOHASH (LOOPING-VAR HASH-TABLE) &BODY BODY

Loops through hash-table. If looping-var is an atom key, loop through the keys; if it is a list of the form (value) loop through the values; if it is a list of the form (key value) loop through key and value.

— Macro: DOTUPLE (INDEX LIMITS &OPTIONAL RESULT) &BODY BODY

Loops through each tuple below limits.

— Function: EMPTYP QUEUE

Tests if queue is empty.

— Function: ENQUEUE OBJECT QUEUE

Puts object into the queue.

— Function: EVALUATE F X

Generic evaluation of functions on an argument. Numbers and arrays are treated as constants. Special evaluation is defined for multivariate polynomials on vectors and for <function> objects.

— Function: FACTORIAL N

Compute the factorial of n. n can also be a list of numbers in which case the product of the factorials of the components is computed.

— Function: FILE-DOCUMENTATION DOCSTRING

If the manual is sorted by file, the string handed to this function describes the use of the respective file.

— Function: FILTER ITEM SEQ &REST REST &KEY TEST TEST-NOT &ALLOW-OTHER-KEYS

The positive REMOVE - i.e. like REMOVE with :test instead of :test-not.

— Function: FIND-LEAF ATOM TREE &KEY (KEY (FUNCTION IDENTITY)) (TEST (FUNCTION EQL))

Finds atom in tree.

— Function: FIND-LEAF-IF TEST TREE &KEY (KEY (FUNCTION IDENTITY))

Finds a leaf in tree where test returns true.

— Function: FIXNUM-VEC &REST ELEMENTS

Returns a FIXNUM-VEC constructed from the parameters.

— Type: FIXNUM-VEC

Vector with elements of type fixnum.

— Function: FLATTEN TREE

Flatten a tree. Example:

            (flatten '((1 2) (3) ((4))))  ⇒  (1 2 3 4)

— Function: FOR-EACH FUNC COLLECTION

Applies func to each element of collection.

— Function: FOR-EACH-TUPLE FUNC LIMITS

Calls func on each tuple greater or equal to (0 ... 0) and below dims.

— Function: GET-ARBITRARY-KEY-FROM-HASH-TABLE HASH-TABLE

Get an arbitrary key from hash-table.

— Function: GET-PROPERTY OBJECT PROPERTY

Gets property for object. Returns NIL also if property is not available.

— Function: GETA ALIST KEY

An analog to GETF for association lists.

— Setf Expander: GETA

An analog to (SETF GETF) for association lists.

— Function: GETBB BLACKBOARD KEY &OPTIONAL DEFAULT

Get the item for key from blackboard. If there is no such key return default.

— Function: GROUP-BY CHARACTERISTIC SEQ &KEY (TEST (QUOTE EQL))

Groups elements in the sequence seq according to characteristic which is a function of one argument. Example:

            (group-by #'second '((1 2) (2 2) (3 4) (4 4)))

— Function: HASH-TABLE-KEYS HASH-TABLE

Collect the keys of hash-table into a list.

— Function: HASH-TABLE-VALUES HASH-TABLE

Collect the values of hash-table into a list.

— Function: IDENTITY-PERMUTATION-P PERM

Checks if the permutation is the identity.

— Function: ITERATOR X

Returns an iterator for x.

— Function: ITERATOR-NEXT VEC ITERATOR

Returns an incremented iterator.

— Function: K->L-SUBSETS SET K L

Returns all subsets of set with length between k and l. Example:

            (k->l-subsets '(1 2 3) 1 2) ⇒
            ((1) (2) (3) (1 2) (1 3) (2 3))

— Function: K-SUBSETS SET K

Returns all subsets of set with length k. Example:

            (k-subsets '(1 2 3) 2)
            ⇒ ((1 2) (1 3) (2 3))

— Function: KEYS DIC

Returns a list of all keys of dic.

— Function: LIST->QUEUE LIST

Transforms list to a queue.

— Macro: LOOP+ ITEMS &BODY BODY

Iterates body over items. Example:

            (let ((x (make-array 10))
          	(y (make-list 10 :initial-element 1)))
              (loop+ ((xc x) (yc y) i) doing
                 (setf xc (+ i yc))
                 finally (return x)))

— Function: MAKE-ANALOG OBJ

Generate an analogous but empty data structure.

— Function: MAKE-FIXNUM-VEC DIM &OPTIONAL (INIT 0)

Construct a FIXNUM-VEC of size dim initialized by init.

— Function: MAP-HASH-TABLE FUNC HASH-TABLE

Call func given in the first argument on each key of hash-table. func must return the new key and the new value as two values. Those pairs are stored in a new hash-table.

— Function: MAP-LIST-IN-HASH-TABLE FUNC LIST &OPTIONAL (TYPE (QUOTE EQL))

Maps the elements of list in a hash-table identified by identifier. func is evaluated on each element and produces two values which are used as key and value for the hash-table.

— Function: MAP-PRODUCT FUNC LIST &REST REST-LISTS

Applies func to a product of lists. Example:

            (map-product #'cons '(2 3) '(1 4))
            ⇒ ((2 . 1) (2 . 4) (3 . 1) (3 . 4))

— Function: MAP-TREE FUNC TREE

Maps tree using func. Example:

            (map-tree #'1+ '((1 (2)))) ⇒ ((2 (3)))

— Macro: MAPF VAR FUNC

Replaces the value of the variable var by setting it to its map with func.

— Function: MAPPEND FUNC &REST LISTS

Map func over lists while appending the results.

— Function: MAPPER-COLLECT MAPPER &REST REST-ARGS

Collects the arguments with which a mapping construct calls a given function. E.g.

          (mapper-collect #'mapc '(3 4 5)) ⇒ (3 4 5)

— Function: MAPPER-COUNT MAPPER &REST REST-ARGS

Counts the arguments with which a mapping construct calls a given function. E.g.

          (mapper-sum #'mapc '(3 4 5)) ⇒ 3

— Function: MAPPER-EVERY TEST MAPPER &REST REST-ARGS

Tests if the test is fulfilled for every argument on which the mapper is called:

          (mapper-every #'plusp #'mapc '(3 4 5)) ⇒ T

— Function: MAPPER-SELECT-FIRST MAPPER &REST REST-ARGS

Select the arguments with which a mapping construct calls a given function. E.g.

          (mapper-select-first #'mapc '(3 4 5) '(7 8 9)) ⇒ 3,7

— Function: MAPPER-SOME TEST MAPPER &REST REST-ARGS

Tests if the test is fulfilled for some argument on which the mapper is called:

          (mapper-some #'plusp #'mapc '(-3 4 5)) ⇒ T

— Function: MAPPER-SUM MAPPER &REST REST-ARGS

Sums the arguments with which a mapping construct calls a given function. E.g.

          (mapper-sum #'mapc '(3 4 5)) ⇒ 12

— Function: MAXIMALLY-CONNECTED CONNECTED DISCONNECTED &KEY (TEST (FUNCTION EQL)) (COMBINE (FUNCTION ADJOIN))

Finds a maximally connected set by taking the union of the elements in connected with the sets of disconnected-sets. Returns the maximally connected sets and the remaining disconnected ones. Example:

            (maximally-connected '(1 2) '((3 4) (2 3) (5 6))
                                 :test #'intersection :combine #'union)
            ⇒ (1 2 3 4), ((5 6))

— Function: MEMOIZE-1 FUNC &KEY (TEST (QUOTE EQL))

Memoizes the function func which should be a non-recursive function of one argument.

— Function: MEMOIZE-SYMBOL FUNSYM &KEY (TEST (QUOTE EQUAL))

Memoizes multi-argument functions named by the symbol funsym.

— Macro: MEMOIZING DEFUN-EXPR

As a global macro it memoizes the following function definition. Inside a with-memoization environment, it memoizes its function argument.

— Macro: MEMOIZING-LET BINDINGS &BODY BODY

The body is memoized for the keys given as a list of bindings.

— Function: MKLIST OBJ

Wraps obj in a list, if it is not already a list.

— Function: N-PARTITIONS-OF-K N K

Returns a list of all ordered partitions of k into n natural numbers. Example:

            (n-partitions-of-k 2 3)
             ⇒ ((0 3) (1 2) (2 1) (3 0))

— Function: NONEMPTY-SUBSETS SET

Returns a list of all nonempty subsets of set.

— Function: ON-LEAVES FUNC TREE

Executes func on the leaves of tree.

— Function: PARTIAL-SUMS SEQ

Returns a sequence of the same type as seq consisting of its partial sums.

— Function: PERMUTATION-INVERSE PERM-VEC

Returns the inverse of the permutation given by perm-vec.

— Function: PERMUTATION-P PERM

Checks if perm is a possible permutation vector. A permutation pi is characterized by a vector containing the indices from 0,..., length(perm)-1 in some order.

— Function: PERMUTATION-SIGNUM PERM

Returns the sign of perm.

— Function: PERMUTE PERM INDEX

Functional version of permute-into.

— Function: PERMUTE-INTO PERM V RESULT

A permutation perm acts on the vector v by permuting it according to result[i] = v[perm[i]].

— Type: POSITIVE-FIXNUM

Positive fixnum tpye.

— Function: POSITIVE-N-PARTITIONS-OF-K N K

Returns a list of all positive ordered partitions of k into n natural numbers. Example:

            (positive-n-partitions-of-k 2 3)
            ⇒ ((1 2) (2 1))

— Function: POSITIVE-PARTITIONS-OF-K K

Returns a list of all positive ordered partitions of k. Example:

            (positive-partitions-of-k 3) ⇒ ((1 2) (2 1))

— Class: PROPERTY-MIXIN

A mixin which adds a slot of properties to the class.

Direct slots:

• PROPERTIES: A property list which is used to store unstructured information about this object.

— Class: QUEUE

Queue class accessed with enqueue and dequeue.

Direct slots:

• HEAD: Self-explanatory.
• TAIL: Self-explanatory.

— Function: QUEUE->LIST QUEUE

Transforms queue to a list.

— Function: RANGE &REST ARGS &KEY TO BELOW

Constructor for a range of numbers.

— Class: RANGE

Range of numbers for iteration.

Direct slots:

• FROM: Start of range, defaults to 0.
• TO: Inclusive end of range, defaults to infinity.
• BELOW: Exclusive end of range, defaults to infinity.
• BY: Step size.

— Function: RCURRY FUNC &REST ARGS

Supplies args to func from the right.

— Function: REFERENCE VEC ITERATOR

Reader for the element of vec referenced by iterator.

— Function: REQUIRED-ARGUMENT

Calling this function results in an error. Such a call may be used as default form when an argument should be supplied.

— Function: SAME-P SEQUENCE &KEY (TEST (FUNCTION EQL)) (KEY (FUNCTION IDENTITY))

Returns t if sequence consists of equal elements.

— Function: SANS PLIST &REST KEYS

Removes the items marked by keys from the property list plist. This function was posted at 2.12.2002 to the comp.lang.lisp newsgroup by Erik Naggum.

— Function: SET-P LIST

Checks if list is a set, i.e. if no members occur twice.

— Class: SMALL-CACHE-DICTIONARY

Implementation with lists.

Direct slots:

• SIZE: Self-explanatory.
• TEST: Self-explanatory.
• STORE: Self-explanatory.

— Class: SORTED-HASH-TABLE

This is a hash-table where entries are guaranteed to be accessed in the order in which they are interned.

Direct slots:

• TEST: Self-explanatory.
• STORE: Self-explanatory.
• ITEM-STORE: Self-explanatory.

— Function: SPLIT-BY-LENGTH ITEMS LENGTHS

Breaks the list items in pieces of lengths determined by nrins. Example:

            (split-by-length '(1 2 3 4) '(1 3)) ⇒ ((1) (2 3 4))

— Function: SQUARE X

Return the square of x.

— Function: SUBSETS SET

Returns a list of all subsets of set.

— Function: TRANSFER-BB FROM-BB TO-BB ITEMS &KEY ENSURE

Transfer items between the blackboards from-bb and to-bb. When ensure is set, an existing item is not modified.

— Function: TRANSLATE ITEM TRANSLATIONS

Performs certain translations from an association table on the string item. Example: (translate "abcdefg" '(("a" . "x") ("b" . "yz")))

— Function: UNBOX BOX

Getter for a boxed object.

— Function: VECTOR-LAST VEC

Reader for the last element of vec.

— Function: VECTOR-MAP FUNC &REST VECS

Map vec with func to a vector of the same type.

— Macro: WITH-ITEMS PROPERTIES BLACKBOARD-FORM &BODY BODY

Work with the items on blackboard corresponding to properties. If some property is a list, the second element is the default value and the third is an alias to be used to refer to this parameter. Example:

            (with-items (&key sol (rhs nil rhs-high)) blackboard
               (setq sol rhs-high))

— Macro: WITH-MEMOIZATION (&KEY (TYPE GLOBAL) SIZE ID (DEBUG T) (TEST (QUOTE (QUOTE EQUAL)))) &BODY BODY

Sets up a memoization environment consisting of a table, and a captured symbol memoizing-let memoizing its body depending on the arguments. Example of usage:

            (with-memoization (:type :local :id 'test)
              (defun test (n)
                (memoizing-let ((k (* 2 n)))
          	(sleep 1)
          	(* k k))))

If type is :global, the table is thread-safe and the same for all threads, if type is :local, it is special for each thread.

— Function: ZERO-VECTOR DIM ELEMENT-TYPE

Returns a uniform vector for the given element type filled with zeros.