The simpsamp Reference Manual

This is the simpsamp Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 08 19:35:05 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 simpsamp

Fast algorithms for simple random sampling from sets, without replacement.

Maintainer

J.P. Larocque

Author

J.P. Larocque

License

ISC-style permissive

Version

0.1

Dependency

jpl-util (system)., at least version "0.2"

Source

simpsamp.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 simpsamp/simpsamp.asd

Source

simpsamp.asd.

Parent Component

simpsamp (system).

ASDF Systems

simpsamp.


3.1.2 simpsamp/core.lisp

Dependency

package.lisp (file).

Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

3.1.3 simpsamp/input.lisp

Dependency

package.lisp (file).

Source

simpsamp.asd.

Parent Component

simpsamp (system).

Internals

3.1.4 simpsamp/output.lisp

Dependency

package.lisp (file).

Source

simpsamp.asd.

Parent Component

simpsamp (system).

Internals

3.1.5 simpsamp/out-do.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

3.1.6 simpsamp/out-map.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

3.1.7 simpsamp/out-list.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

3.1.8 simpsamp/out-vector.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

3.1.9 simpsamp/out-hash-table.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

hash-table-sample-of-hash-table (function).


3.1.10 simpsamp/unbounded-iterator.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

vector-sample-of-unbounded-iterator (function).


3.1.11 simpsamp/generic-functions.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface
Internals

define-typical-sample-methods (macro).


3.1.12 simpsamp/test.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Public Interface

test (function).


3.1.13 simpsamp/test-core.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Internals

3.1.14 simpsamp/test-outputs.lisp

Dependencies
Source

simpsamp.asd.

Parent Component

simpsamp (system).

Internals

3.1.15 simpsamp/package.lisp

Source

simpsamp.asd.

Parent Component

simpsamp (system).

Packages

simpsamp.


4 Packages

Packages are listed by definition order.


4.1 simpsamp

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Macros

Macro: do-sample-of-hash-table ((key-var value-var n-form hash-table-form &rest kw-args &key &allow-other-keys) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: do-sample-of-iterator ((vars n-form size-form next-fn-form &rest kw-args &key &allow-other-keys) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: do-sample-of-iterator-expr ((vars n-form size-form next-form &key effective-n-var initial-form result-form) &body body)

Iterates over a simple random sample of N-FORM elements, without replacement, from a set expressed by SIZE-FORM and NEXT-FORM.

N-FORM is evaluated once, before any other arguments are evaluated. If the value of N-FORM is larger than the size of the input set, then the resulting sample will just contain all the elements of the set–that is, the value of N-FORM is automatically lowered to the size of the input set when necessary.

SIZE-FORM is then evaluated once to produce the number of elements in the set.

When INITIAL-FORM is given, it is evaluated before iteration begins. When RESULT-FORM is given, it is evaluated after iteration ends, and its resulting values become the result of the iteration form; if RESULT-FORM is not given, the result is NIL. If EFFECTIVE-N-VAR is given, it is bound with the effective number of elements to process (the result of N-FORM limited by the actual size of the input set) for the evaluation of INITIAL-FORM, NEXT-FORM, RESULT-FORM, and BODY.

NEXT-FORM is evaluated to produce the next available element, advancing through the set. NEXT-FORM may produce multiple values; these values taken together as a tuple constitute a single element of the set. NEXT-FORM will never be evaluated more times than the value of SIZE-FORM.

For each element selected for the random sample, BODY is evaluated with the symbol specified by VARS bound to a list of each value of the element (the values yielded by NEXT-FORM). Alternatively, VARS may be a list of symbols, each of which is bound to each successive value of the element, as if by MULTIPLE-VALUE-BIND. In either case, the bindings may be shared between different iterations, or the binding may be fresh each time.

An implicit block named NIL is established around the loop. RETURN may be used to terminate the loop prematurely, overriding the default resulting values of the iteration form (controlled by RESULT-FORM).

The order in which BODY is evaluated on the sampled elements is not assured to be random. The only thing that is random is which selection is made of all the possible subsets of the input set with the size expressed by N-FORM.

Package

simpsamp.

Source

core.lisp.

Macro: do-sample-of-list ((var n-form list-form &rest kw-args &key &allow-other-keys) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: do-sample-of-range ((var n-form lower-form upper-form &rest kw-args &key &allow-other-keys) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: do-sample-of-unbounded-iterator ((var n-form next-fn-form exhausted?-fn-form &key effective-n-var initial-form result-form) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: do-sample-of-vector ((var n-form vector-form &rest kw-args &key &allow-other-keys) &body body)
Package

simpsamp.

Source

out-do.lisp.

Macro: vector-sample-of-unbounded-iterator-expr (n-form next-form exhausted?-form)

Evaluates to a simple random sample of size N-FORM, without replacement, from a set of unknown size expressed by NEXT-FORM and EXHAUSTED?-FORM. The resulting sample is expressed as a vector.

N-FORM is evaluated once, before any other arguments are evaluated. If the value of N-FORM is larger than the size of the input set, then the resulting sample will just contain all the elements of the set–that is, the value of N-FORM is automatically lowered to the size of the input set when necessary. The value of N-FORM (before being limited by the size of the input set) must be within the host implementation’s ARRAY-DIMENSION-LIMIT.

NEXT-FORM is evaluated to produce the next available element, advancing through the input set. (Its first return value is used as the element, or NIL if NEXT-FORM produced no values.) EXHAUSTED?-FORM is evaluated to produce a generalized boolean indicating whether the input set has been exhausted. NEXT-FORM will never be evaluated unless EXHAUSTED?-FORM has been evaluated since the last evaluation of NEXT-FORM, and the result was false.

The order of the returned elements is not assured to be random. The only thing that is random is which selection is made of all the possible subsets of the input set with the size expressed by N-FORM.

Package

simpsamp.

Source

core.lisp.


5.1.2 Ordinary functions

Function: hash-table-sample-of-hash-table (n hash-table)
Package

simpsamp.

Source

out-hash-table.lisp.

Function: list-sample-of-hash-table-keys (n hash-table)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-hash-table-pairs (n hash-table)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-hash-table-values (n hash-table)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-iterator (n size next-fn)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-list (n list)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-range (n lower upper)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-unbounded-iterator (n next-fn exhausted?-fn)
Package

simpsamp.

Source

out-list.lisp.

Function: list-sample-of-vector (n vector)
Package

simpsamp.

Source

out-list.lisp.

Function: map-sample-of-hash-table (function n hash-table)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-hash-table-keys (function n hash-table)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-hash-table-values (function n hash-table)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-iterator (function n size next-fn)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-list (function n list)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-range (function n lower upper)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-unbounded-iterator (function n next-fn exhausted?-fn)
Package

simpsamp.

Source

out-map.lisp.

Function: map-sample-of-vector (function n vector)
Package

simpsamp.

Source

out-map.lisp.

Function: test (&rest test-core-args &key stream &allow-other-keys)
Package

simpsamp.

Source

test.lisp.

Function: vector-sample-of-hash-table-keys (n hash-table)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-hash-table-pairs (n hash-table)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-hash-table-values (n hash-table)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-iterator (n size next-fn)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-list (n list)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-range (n lower upper)
Package

simpsamp.

Source

out-vector.lisp.

Function: vector-sample-of-unbounded-iterator (n next-fn exhausted?-fn)
Package

simpsamp.

Source

unbounded-iterator.lisp.

Function: vector-sample-of-vector (n vector)
Package

simpsamp.

Source

out-vector.lisp.


5.1.3 Generic functions

Generic Function: list-sample (n set)

Like SAMPLE, but the result is a LIST.

Package

simpsamp.

Source

generic-functions.lisp.

Methods
Method: list-sample ((n integer) (set hash-table))
Method: list-sample ((n integer) (set vector))
Method: list-sample ((n integer) (set list))
Generic Function: map-sample (function n set)

Like SAMPLE, but applies FUNCTION to each element
of the resulting selection.

When SET is a mapping type (e.g. a HASH-TABLE), FUNCTION is applied with two arguments: the key and the value.

Package

simpsamp.

Source

generic-functions.lisp.

Methods
Method: map-sample (function (n integer) (set hash-table))
Method: map-sample (function (n integer) (set vector))
Method: map-sample (function (n integer) (set list))
Generic Function: sample (n set)

Returns a simple random sample of size N, without
replacement, from SET. The output will be of type SEQUENCE. (Whether a LIST is returned or a VECTOR depends on which is most efficient for the type of SET.)

If N is larger than the size of SET, then the resulting sample will just contain all the elements of SET–that is, N is automatically lowered to the size of SET when necessary.

When SET is a mapping type (e.g. a HASH-TABLE), the returned elements will be CONSes of the form (KEY . VALUE).

The order of the returned elements is not assured to be random. The only thing that is random is which selection is made of all the possible subsets of SET of size N.

Package

simpsamp.

Source

generic-functions.lisp.

Methods
Method: sample ((n integer) (set hash-table))
Method: sample ((n integer) (set vector))
Method: sample ((n integer) (set list))
Generic Function: vector-sample (n set)

Like SAMPLE, but the result is a VECTOR.

Package

simpsamp.

Source

generic-functions.lisp.

Methods
Method: vector-sample ((n integer) (set hash-table))
Method: vector-sample ((n integer) (set vector))
Method: vector-sample ((n integer) (set list))

5.2 Internals


5.2.1 Special variables

Special Variable: *test-output-lower-bound*
Package

simpsamp.

Source

test-outputs.lisp.

Special Variable: *test-output-upper-bound*
Package

simpsamp.

Source

test-outputs.lisp.


5.2.2 Macros

Macro: define-typical-sample-methods (specialized-for-class-name generic-sample-function-name list-sample-function-name vector-sample-function-name map-sample-function-name)
Package

simpsamp.

Source

generic-functions.lisp.

Macro: test-accumulated-sample ((label accumulate input-set-form requested-sample-size-form) &body body)

Evaluates BODY, which accumulates the elements of a sample taken from a set. After evaluating BODY, tests the sample against the input set and the requested sample size. If there is an error in the resulting sample, an error is signalled. LABEL is included in any error messages.

ACCUMULATE is defined with MACROLET for the evaluation of BODY. (ACCUMULATE ELEMENT) is used to accumulate each ELEMENT of the sample that is taken.

INPUT-SET-FORM is evaluated to produce the input set (or an equivalent copy), as a SEQUENCE.

REQUESTED-SAMPLE-SIZE-FORM is evaluated to produce the requested size of the sample to take.

Note that the input set and requested sample size are not passed to anything within BODY, but must be equivalent to the corresponding arguments to the function or macro form used in BODY to produce the sample.

Package

simpsamp.

Source

test-outputs.lisp.

Macro: test-do-sample ((label accumulate initial-form result-form initial-set-form requested-sample-size-form) &body body)

Evaluates BODY, which iterates over the elements of a sample taken from a set. After evaluating BODY, tests the sample against the input set and the requested sample size. If there is an error in the resulting sample, an error is signalled. LABEL is included in any error messages.

ACCUMULATE is defined with MACROLET for the evaluation of BODY. The result of BODY must be the result a DO-SAMPLE-OF-* macro form that includes at least the expression (ACCUMULATE ELEMENT) in its body (where ELEMENT is the variable naming the current element in the loop over the resulting sample). BODY should consist solely of the DO-SAMPLE-OF-* macro form, and the body of that macro form should consist solely of (ACCUMULATE ELEMENT).

INITIAL-FORM is defined with MACROLET for the evaluation of BODY. (INITIAL-FORM) must be the :INITIAL-FORM argument to the DO-SAMPLE-OF-* macro form.

RESULT-FORM is defined with MACROLET for the evaluation of BODY. (RESULT-FORM) must be the :RESULT-FORM argument to the DO-SAMPLE-OF-* macro form.

INPUT-SET-FORM is evaluated to produce the input set (or an equivalent copy), as a SEQUENCE.

REQUESTED-SAMPLE-SIZE-FORM is evaluated to produce the requested size of the sample to take.

Note that the input set and requested sample size are not passed to anything within BODY, but must be equivalent to the corresponding arguments to the DO-SAMPLE-OF-* macro form used in BODY to produce the sample.

Package

simpsamp.

Source

test-outputs.lisp.

Macro: test-list-sample ((label input-set-form requested-sample-size-form) &body body)

Evaluates BODY, which takes a sample from a set, evaluating to the sample (as a LIST). The sample is tested against the input set and the requested sample size. If there is an error in the resulting sample, an error is signalled. LABEL is included in any error messages.

INPUT-SET-FORM and REQUESTED-SAMPLE-SIZE-FORM have the same meaning as they do in the TEST-ACCUMULATED-SAMPLE macro.

Package

simpsamp.

Source

test-outputs.lisp.

Macro: test-vector-sample ((label input-set-form requested-sample-size-form) &body body)

Evaluates BODY, which takes a sample from a set, evaluating to the sample (as a VECTOR). The sample is tested against the input set and the requested sample size. If there is an error in the resulting sample, an error is signalled. LABEL is included in any error messages.

INPUT-SET-FORM and REQUESTED-SAMPLE-SIZE-FORM have the same meaning as they do in the TEST-ACCUMULATED-SAMPLE macro.

Package

simpsamp.

Source

test-outputs.lisp.

Macro: with-hash-table-accumulator ((set-test/size accumulate) &body body)

Evaluates BODY, accumulating keys and values to a hash-table, resulting in the hash-table.

SET-TEST/SIZE is defined with MACROLET. (SET-TEST/SIZE TEST SIZE) must be evaluated once, before accumulation begins. TEST must be an acceptable hash-table test function for MAKE-HASH-TABLE. SIZE must be a non-negative integer indicating the expected final size of the hash-table (the number of times ACCUMULATE is evaluated with a unique KEY), which need not be accurate, or NIL to make no guess as to the final size.

ACCUMULATE is defined with MACROLET. Each time (ACCUMULATE KEY VALUE) is evaluated, KEY and TABLE are added as an entry to the hash-table, replacing any previous entry with the same KEY.

Package

simpsamp.

Source

output.lisp.

Macro: with-list-accumulator ((accumulate) &body body)

Evaluates BODY, accumulating elements to a list, resulting in the list. The order of the elements of the resulting list is undefined.

ACCUMULATE is defined with MACROLET. Each time (ACCUMULATE ELEMENT) is evaluated, ELEMENT is accumulated to the list.

Package

simpsamp.

Source

output.lisp.

Macro: with-list-iterator ((next size exhausted? list-form) &body body)

Evaluates BODY with an iterator on a list.

LIST-FORM is evaluated once to produce the list to iterate upon. The resulting list is never modified (unless from within BODY), the consequences of which are undefined).

NEXT is defined with MACROLET. Each evaluation of (NEXT) yields the next successive element of the list.

SIZE is defined with MACROLET. Each evaluation of (SIZE) yields the length of the list. The length may or may not be calculated upon each evaluation; it may (but need not be) be memoized.

EXHAUSTED? is defined with MACROLET?. Each evaluation of (EXHAUSTED?) yields a generalized boolean indicating whether the list has been exhausted by evaluations of NEXT.

The effect of calling NEXT more times than the length of the list is undefined.

Package

simpsamp.

Source

input.lisp.

Macro: with-range-iterator ((next size exhausted? lower-form upper-form) &body body)

Evaluates BODY with an iterator on a range of integers.

LOWER-FORM and UPPER-FORM are evaluated once to produce the range of integers, [LOWER,UPPER), to iterate upon.

NEXT is defined with MACROLET. Each evaluation of (NEXT) yields the next successive element of the range.

SIZE is defined with MACROLET. Each evaluation of (SIZE) yields the length of the range.

EXHAUSTED? is defined with MACROLET?. Each evaluation of (EXHAUSTED?) yields a generalized boolean indicating whether the range has been exhausted by evaluations of NEXT.

The effect of calling NEXT more times than the length of the range is undefined.

Package

simpsamp.

Source

input.lisp.

Macro: with-vector-accumulator ((set-size/element-type accumulate) &body body)

Evaluates BODY, accumulating elements to a vector, resulting in the vector. The order of the elements of the resulting vector is undefined.

SET-SIZE/ELEMENT-TYPE is defined with
MACROLET. (SET-SIZE/ELEMENT-TYPE SIZE ELEMENT-TYPE) must be evaluated once, before accumulation begins. SIZE dictates the size of the resulting vector. ELEMENT-TYPE is a designator for the type of elements to be accumulated. The result of accumulating an element not of type ELEMENT-TYPE is undefined.

ACCUMULATE is defined with MACROLET. Each time (ACCUMULATE ELEMENT) is evaluated, ELEMENT is accumulated to the vector. It must be evaluated exactly the number of times as given to the SET-SIZE/ELEMENT-TYPE form before control leaves BODY in the normal manner. (It’s acceptable for control to leave BODY due to non-local exits, such as GO, THROW, or a signalled condition.)

Package

simpsamp.

Source

output.lisp.

Macro: with-vector-iterator ((next size exhausted? vector-form) &body body)

Evaluates BODY with an iterator on a vector.

VECTOR-FORM is evaluated once to produce the vector to iterate upon. The resulting vector is never modified (unless from within BODY, the consequences of which are undefined).

NEXT is defined with MACROLET. Each evaluation of (NEXT) yields the next successive element of the vector.

SIZE is defined with MACROLET. Each evaluation of (SIZE) yields the length of the vector.

EXHAUSTED? is defined with MACROLET?. Each evaluation of (EXHAUSTED?) yields a generalized boolean indicating whether the vector has been exhausted by evaluations of NEXT.

The effect of calling NEXT more times than the length of the vector is undefined.

Package

simpsamp.

Source

input.lisp.


5.2.3 Ordinary functions

Function: list->hash-table (list)

Given LIST, a list of 2-lists of the form (KEY VALUE), returns a hash table mapping each KEY to each corresponding VALUE.

Package

simpsamp.

Source

test-outputs.lisp.

Function: list->iterator-mv (list)

Returns two values: the length of LIST and a function that successively returns the lists of LIST as multiple values.

Package

simpsamp.

Source

test-outputs.lisp.

Function: list->unbounded-iterator (list)

Returns two values: a function that successively returns the values of LIST, and a function that returns a generalized boolean indicating whether the first function has exhausted LIST.

Package

simpsamp.

Source

test-outputs.lisp.

Function: make-test-set-as-list ()

Returns a sample set (as a list) of lists, each list consisting of two elements.

Package

simpsamp.

Source

test-outputs.lisp.

Function: make-test-set-as-range ()

Returns three values to use as a range set: a lower bound, an upper bound, and a list of the values of the range.

Package

simpsamp.

Source

test-outputs.lisp.

Function: make-test-set-as-vector ()

Returns the sample set from MAKE-TEST-SET-AS-LIST, but as a vector.

Package

simpsamp.

Source

test-outputs.lisp.

Function: measure-selection-rates (iterations set-lower set-upper sample-size sample-fn)

Given the set of integers [SET-LOWER,SET-UPPER), measures the selection rates of each element when repeatedly given to SAMPLE-FN, which takes a simple random sample, without replacement, of the set. SAMPLE-SIZE is the size of each sample.

The function SAMPLE-FN is called ITERATIONS times. Its arguments are:

SAMPLE-SIZE
The requested size of the sample to take of the set.

SET-SIZE
The size of the set.

SET-NEXT
A function of no arguments returning the next element of the set.

SET-EXHAUSTED?
A function of no arguments returning a generalized boolean indicating whether the set has been exhausted.

VISIT-SAMPLE-ELEMENT
A function which must be called once for every element of the chosen sample.

Returns two values: the expected rate of selection for all elements, based on the set size and sample size, and a vector of the actual measured rate of selection for each element of the set; each element of the vector corresponds to [SET-LOWER,SET-UPPER) (in the same order).

The more any actual rate varies from the expected rate, the more likely there was some bias or error in the sample taken by SAMPLE-FN. A lower number of iterations can also cause this problem; 1,000,000 is a good number of iterations to use to get a clear reading.

Package

simpsamp.

Source

test-core.lisp.

Function: report-selection-rates (label expected-rate actual-rates verbose-p stream)

Reports EXPECTED-RATE and some trivial statistics on ACTUAL-RATES, as returned by MEASURE-SELECTION-RATES. Prints the analysis to STREAM.

When VERBOSE-P is true, prints each element of ACTUAL-RATES, along with its error from EXPECTED-RATE and a graph of its error.

Package

simpsamp.

Source

test-core.lisp.

Function: test-computed-sample (label sample sample-type input-set requested-sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-core (&key iterations set-lower set-upper sample-size stream verbose-p)
Package

simpsamp.

Source

test-core.lisp.

Function: test-output ()
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-as-hash-table (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-as-iteration (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-as-list (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-as-mapping (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-as-vector (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.

Function: test-output-methods (sample-size)
Package

simpsamp.

Source

test-outputs.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   D   F   G   H   L   M   R   S   T   V   W  
Index Entry  Section

D
define-typical-sample-methods: Private macros
do-sample-of-hash-table: Public macros
do-sample-of-iterator: Public macros
do-sample-of-iterator-expr: Public macros
do-sample-of-list: Public macros
do-sample-of-range: Public macros
do-sample-of-unbounded-iterator: Public macros
do-sample-of-vector: Public macros

F
Function, hash-table-sample-of-hash-table: Public ordinary functions
Function, list->hash-table: Private ordinary functions
Function, list->iterator-mv: Private ordinary functions
Function, list->unbounded-iterator: Private ordinary functions
Function, list-sample-of-hash-table-keys: Public ordinary functions
Function, list-sample-of-hash-table-pairs: Public ordinary functions
Function, list-sample-of-hash-table-values: Public ordinary functions
Function, list-sample-of-iterator: Public ordinary functions
Function, list-sample-of-list: Public ordinary functions
Function, list-sample-of-range: Public ordinary functions
Function, list-sample-of-unbounded-iterator: Public ordinary functions
Function, list-sample-of-vector: Public ordinary functions
Function, make-test-set-as-list: Private ordinary functions
Function, make-test-set-as-range: Private ordinary functions
Function, make-test-set-as-vector: Private ordinary functions
Function, map-sample-of-hash-table: Public ordinary functions
Function, map-sample-of-hash-table-keys: Public ordinary functions
Function, map-sample-of-hash-table-values: Public ordinary functions
Function, map-sample-of-iterator: Public ordinary functions
Function, map-sample-of-list: Public ordinary functions
Function, map-sample-of-range: Public ordinary functions
Function, map-sample-of-unbounded-iterator: Public ordinary functions
Function, map-sample-of-vector: Public ordinary functions
Function, measure-selection-rates: Private ordinary functions
Function, report-selection-rates: Private ordinary functions
Function, test: Public ordinary functions
Function, test-computed-sample: Private ordinary functions
Function, test-core: Private ordinary functions
Function, test-output: Private ordinary functions
Function, test-output-as-hash-table: Private ordinary functions
Function, test-output-as-iteration: Private ordinary functions
Function, test-output-as-list: Private ordinary functions
Function, test-output-as-mapping: Private ordinary functions
Function, test-output-as-vector: Private ordinary functions
Function, test-output-methods: Private ordinary functions
Function, vector-sample-of-hash-table-keys: Public ordinary functions
Function, vector-sample-of-hash-table-pairs: Public ordinary functions
Function, vector-sample-of-hash-table-values: Public ordinary functions
Function, vector-sample-of-iterator: Public ordinary functions
Function, vector-sample-of-list: Public ordinary functions
Function, vector-sample-of-range: Public ordinary functions
Function, vector-sample-of-unbounded-iterator: Public ordinary functions
Function, vector-sample-of-vector: Public ordinary functions

G
Generic Function, list-sample: Public generic functions
Generic Function, map-sample: Public generic functions
Generic Function, sample: Public generic functions
Generic Function, vector-sample: Public generic functions

H
hash-table-sample-of-hash-table: Public ordinary functions

L
list->hash-table: Private ordinary functions
list->iterator-mv: Private ordinary functions
list->unbounded-iterator: Private ordinary functions
list-sample: Public generic functions
list-sample: Public generic functions
list-sample: Public generic functions
list-sample: Public generic functions
list-sample-of-hash-table-keys: Public ordinary functions
list-sample-of-hash-table-pairs: Public ordinary functions
list-sample-of-hash-table-values: Public ordinary functions
list-sample-of-iterator: Public ordinary functions
list-sample-of-list: Public ordinary functions
list-sample-of-range: Public ordinary functions
list-sample-of-unbounded-iterator: Public ordinary functions
list-sample-of-vector: Public ordinary functions

M
Macro, define-typical-sample-methods: Private macros
Macro, do-sample-of-hash-table: Public macros
Macro, do-sample-of-iterator: Public macros
Macro, do-sample-of-iterator-expr: Public macros
Macro, do-sample-of-list: Public macros
Macro, do-sample-of-range: Public macros
Macro, do-sample-of-unbounded-iterator: Public macros
Macro, do-sample-of-vector: Public macros
Macro, test-accumulated-sample: Private macros
Macro, test-do-sample: Private macros
Macro, test-list-sample: Private macros
Macro, test-vector-sample: Private macros
Macro, vector-sample-of-unbounded-iterator-expr: Public macros
Macro, with-hash-table-accumulator: Private macros
Macro, with-list-accumulator: Private macros
Macro, with-list-iterator: Private macros
Macro, with-range-iterator: Private macros
Macro, with-vector-accumulator: Private macros
Macro, with-vector-iterator: Private macros
make-test-set-as-list: Private ordinary functions
make-test-set-as-range: Private ordinary functions
make-test-set-as-vector: Private ordinary functions
map-sample: Public generic functions
map-sample: Public generic functions
map-sample: Public generic functions
map-sample: Public generic functions
map-sample-of-hash-table: Public ordinary functions
map-sample-of-hash-table-keys: Public ordinary functions
map-sample-of-hash-table-values: Public ordinary functions
map-sample-of-iterator: Public ordinary functions
map-sample-of-list: Public ordinary functions
map-sample-of-range: Public ordinary functions
map-sample-of-unbounded-iterator: Public ordinary functions
map-sample-of-vector: Public ordinary functions
measure-selection-rates: Private ordinary functions
Method, list-sample: Public generic functions
Method, list-sample: Public generic functions
Method, list-sample: Public generic functions
Method, map-sample: Public generic functions
Method, map-sample: Public generic functions
Method, map-sample: Public generic functions
Method, sample: Public generic functions
Method, sample: Public generic functions
Method, sample: Public generic functions
Method, vector-sample: Public generic functions
Method, vector-sample: Public generic functions
Method, vector-sample: Public generic functions

R
report-selection-rates: Private ordinary functions

S
sample: Public generic functions
sample: Public generic functions
sample: Public generic functions
sample: Public generic functions

T
test: Public ordinary functions
test-accumulated-sample: Private macros
test-computed-sample: Private ordinary functions
test-core: Private ordinary functions
test-do-sample: Private macros
test-list-sample: Private macros
test-output: Private ordinary functions
test-output-as-hash-table: Private ordinary functions
test-output-as-iteration: Private ordinary functions
test-output-as-list: Private ordinary functions
test-output-as-mapping: Private ordinary functions
test-output-as-vector: Private ordinary functions
test-output-methods: Private ordinary functions
test-vector-sample: Private macros

V
vector-sample: Public generic functions
vector-sample: Public generic functions
vector-sample: Public generic functions
vector-sample: Public generic functions
vector-sample-of-hash-table-keys: Public ordinary functions
vector-sample-of-hash-table-pairs: Public ordinary functions
vector-sample-of-hash-table-values: Public ordinary functions
vector-sample-of-iterator: Public ordinary functions
vector-sample-of-list: Public ordinary functions
vector-sample-of-range: Public ordinary functions
vector-sample-of-unbounded-iterator: Public ordinary functions
vector-sample-of-unbounded-iterator-expr: Public macros
vector-sample-of-vector: Public ordinary functions

W
with-hash-table-accumulator: Private macros
with-list-accumulator: Private macros
with-list-iterator: Private macros
with-range-iterator: Private macros
with-vector-accumulator: Private macros
with-vector-iterator: Private macros


A.4 Data types

Jump to:   C   F   G   I   O   P   S   T   U  
Index Entry  Section

C
core.lisp: The simpsamp/core․lisp file

F
File, core.lisp: The simpsamp/core․lisp file
File, generic-functions.lisp: The simpsamp/generic-functions․lisp file
File, input.lisp: The simpsamp/input․lisp file
File, out-do.lisp: The simpsamp/out-do․lisp file
File, out-hash-table.lisp: The simpsamp/out-hash-table․lisp file
File, out-list.lisp: The simpsamp/out-list․lisp file
File, out-map.lisp: The simpsamp/out-map․lisp file
File, out-vector.lisp: The simpsamp/out-vector․lisp file
File, output.lisp: The simpsamp/output․lisp file
File, package.lisp: The simpsamp/package․lisp file
File, simpsamp.asd: The simpsamp/simpsamp․asd file
File, test-core.lisp: The simpsamp/test-core․lisp file
File, test-outputs.lisp: The simpsamp/test-outputs․lisp file
File, test.lisp: The simpsamp/test․lisp file
File, unbounded-iterator.lisp: The simpsamp/unbounded-iterator․lisp file

G
generic-functions.lisp: The simpsamp/generic-functions․lisp file

I
input.lisp: The simpsamp/input․lisp file

O
out-do.lisp: The simpsamp/out-do․lisp file
out-hash-table.lisp: The simpsamp/out-hash-table․lisp file
out-list.lisp: The simpsamp/out-list․lisp file
out-map.lisp: The simpsamp/out-map․lisp file
out-vector.lisp: The simpsamp/out-vector․lisp file
output.lisp: The simpsamp/output․lisp file

P
Package, simpsamp: The simpsamp package
package.lisp: The simpsamp/package․lisp file

S
simpsamp: The simpsamp system
simpsamp: The simpsamp package
simpsamp.asd: The simpsamp/simpsamp․asd file
System, simpsamp: The simpsamp system

T
test-core.lisp: The simpsamp/test-core․lisp file
test-outputs.lisp: The simpsamp/test-outputs․lisp file
test.lisp: The simpsamp/test․lisp file

U
unbounded-iterator.lisp: The simpsamp/unbounded-iterator․lisp file