The screamer Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The screamer Reference Manual

This is the screamer Reference Manual, version 4.0.0, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:33:30 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

-*- mode: text; mode: auto-fill; fill-column: 78 -*-

Screamer is an extension of Common Lisp that adds support for nondeterministic
programming. Screamer consists of two levels. The basic nondeterministic level
adds support for backtracking and undoable side effects. On top of this
nondeterministic substrate, Screamer provides a comprehensive constraint
programming language in which one can formulate and solve mixed systems of
numeric and symbolic constraints. Together, these two levels augment Common
Lisp with practically all of the functionality of both Prolog and constraint
logic programming languages such as CHiP and CLP(R). Furthermore, Screamer is
fully integrated with Common Lisp. Screamer programs can coexist and
interoperate with other extensions to as CLIM and Iterate.

In several ways Screamer is more efficient than other implementations of
backtracking languages. First, Screamer code is transformed into Common Lisp
which can be compiled by the underlying Common Lisp system. Many competing
implementations of nondeterministic Lisp are interpreters and thus are far
less efficient than Screamer. Second, the backtracking primitives require
fairly low overhead in Screamer. Finally, this overhead to support
backtracking is only paid for by those portions of the program which use the
backtracking primitives. Deterministic portions of user programs pass through
the Screamer-to-Common-Lisp transformation unchanged. Since in practise, only
small portions of typical programs utilize the backtracking primitives,
Screamer can produce more efficient code than compilers for languages in which
backtracking is more pervasive.

Screamer was written by Jeffrey Mark Siskind and David Allen McAllester, see
file LICENSE for licensing information.

This version of Screamer is based on released version 3.20, and is
being dragged kicking -- and screaming -- into the 21st century:

* Support for Symbolics, AKCL, etc. has been stripped.

* It has been modified to run in ANSI Common Lisp, as opposed to CLtL1/CLtL2.

* Ongoing maintenance work: original screamer.lisp has been split into
  package.lisp and screamer.lisp, ChangeLog.old, and some information
  has been moved over to TODO.

* Ongoing development and documentation work: a new manual is in the making,
  and add support for missing Common Lisp special forms in nondeterministic
  context is planned. ...the progress is rather glacial, however. Don't hold
  your breath.

See TODO for the current task list.

Source files part of the distribution not currently referenced in the
screamer.asd:

screams.lisp - A file containing all of the examples from the Screamer manual
and the two papers ircs-93-03 and aaai93. To use, first compile and load
Screamer and Iterate, compile and load this file, and then type
(IN-PACKAGE :SCREAMS).

equations.lisp - A file containing some equations for testing Screamer's
numeric constraint satisfaction procedures. To use, first compile and load
Screamer, compile and load this file, and then type (IN-PACKAGE :SCREAMS).

iscream.el - If you run Lisp on Unix under GNUEmacs using ILisp you can load
this Emacs Lisp file (preferably byte compiled first). You must also then
set the variable SCREAMER:*ISCREAM?* to T. This will enable the Screamer
macro LOCAL-OUTPUT and improve the behavior of Y-OR-N-P and PRINT-VALUES
under ILisp.

Subdirectory papers/ contains the original Screamer manual and papers:

screamer.pdf
screamer.dvi
screamer.ps - PDF, DVI, and Postscript versions of an outdated manual for
Screamer. The code in this manual has some bugs but corrected versions are
included in screams.lisp.

ircs-93-03.pdf
ircs-93-03.dvi
ircs-93-03.ps - PDF, DVI, and Postscript versions of a paper describing the
fundamentals of nondeterministic CommonLisp. This paper is available at
Technical Report 93-03 of the University of Pennsylvania Institute for
Research in Cognitive Science. The appropriate BibTeX entry is:
\newcommand{\Screamer}{{\mbox{\sc Screamer}}}
\newcommand{\CommonLisp}{{\mbox{\sc Common Lisp}}}
@string{IRCS = {University of Pennsylvania Institute for Research in Cognitive
	Science}}
@techreport{SiskindM93,
	author = {Jeffrey Mark Siskind and David Allen McAllester},
	title = {{\Screamer:} A Portable Efficient Implementation of
		Nondeterministic {\CommonLisp}},
	institution = IRCS,
	year = 1993,
        number = {IRCS--93--03}}
The code in this paper is included in screams.lisp.

aaai93.pdf
aaai93.dvi
aaai93.ps - PDF, DVI, and Postscript versions of a paper describing the
constraint package included with Screamer. This paper will appear in the
Proceedings of AAAI-93. The appropriate BibTeX entry is:
The code in this paper is also included in screams.lisp.
\newcommand{\Lisp}{{\mbox{\sc Lisp}}}
@string{AAAI93 = {Proceedings of the Eleventh National Conference on
	Artifical Intelligence}}
@inproceedings{SiskindM93a,
	author = {Jeffrey Mark Siskind and David Allen McAllester},
	title = {Nondeterministic {\Lisp} as a Substrate for Constraint Logic
		Programming},
	booktitle = AAAI93,
	year = 1993,
	month = jul}

Following are old notes regarding incompatibilities between Screamer 3.20 and
Screamer 2.4 (as eg. described in papers/screamer.ps):

Screamer 3.20 contains numerous bug fixes, performance enhancements and novel
features over Screamer 2.4, the prior widely released version. I do not have
the time to describe all such improvements. Until the completion of a new
Screamer manual you must resort to looking at the source code. At the beginning
of the file there is a fairly extensive change log.

A small number of incompatibilities have been introduced in the transition
from Screamer 2.4 to Screamer 3.20. These are summarized below. Those already
familiar with Screamer should have no difficulty modifying their code modulo
these changes.

1. All Screamer code must be recompiled. The Screamer 3.20 runtime is
incompatibile with the Screamer 2.4 compiler.

2. The function MAP-VALUES has been removed. An expression such as:
(MAP-VALUES function expression)
can be rewritten using the new FOR-EFFECTS macro as follows:
(FOR-EFFECTS (FUNCALL function expression))
The new syntax is every bit as powerful as the old syntax. In fact it is more
powerfull. MAP-VALUES used to require that the function argument be a
deterministic expression while the new syntax makes no such requirement. (Note
that FUNCALL still requires that its first argument evaluate to a deterministic
function.)

3. You no longer need to reload Screamer after doing an UNWEDGE-SCREAMER since
Screamer keeps track of which functions are intrinsic and UNWEDGE-SCREAMER
does not purge those functions.

4. The following functions have been renamed:
NUMBERV  -> NUMBERPV
REALV    -> REALPV
INTEGERV -> INTEGERPV
BOOLEANV -> BOOLEANPV
The original names were inconsistent with the naming convention that every
function ending in V names a lifted version of the function name without the V.
I.e. NUMBERV would have been a lifted version of a function NUMBER but there
is no ground function. NUMBERV was really a lifted version of NUMBERP and thus
should have been named NUMBERPV.

5. A new naming convention has been introduced. All nondeterministic
`generators' now begin with the prefix A- or AN-. This results in the
following name changes:
INTEGER-BETWEEN -> AN-INTEGER-BETWEEN
MEMBER-OF       -> A-MEMBER-OF
FLIP            -> A-BOOLEAN
Furthermore, `lifted generators' both begin with A- or AN- and end with V.
This results in the following name changes:
REAL-ABOVEV      -> A-REAL-ABOVEV
REAL-BELOWV      -> A-REAL-BELOWV
REAL-BETWEENV    -> A-REAL-BETWEENV
INTEGER-ABOVEV   -> AN-INTEGER-ABOVEV
INTEGER-BELOWV   -> AN-INTEGER-BELOWV
INTEGER-BETWEENV -> AN-INTEGER-BETWEENV

6. The variable *FUZZ* has been eliminated. The functionality of this variable
has been replaced by additional arguments to the REORDER function.

7. REORDER now takes four arguments:
(COST-FUNCTION TERMINATE? ORDER FORCE-FUNCTION)
instead of one. The FORCE-FUNCTION is the same as the prior lone argument.
The COST-FUNCTION is a function to be applied to each VARIABLE at each
reordering step to return its cost. Typical values for COST-FUNCTION are
#'DOMAIN-SIZE or #'RANGE-SIZE. The COST-FUNCTION can return NIL which causes
REORDER to not consider that variable for further forcing. ORDER is a two
argument predicate applied to the non-NIL cost functions computed for the
variables at each reordering step. Typical values are #'<, to choose the least
cost, and #'>, to choose the greatest cost variable to force next. TERMINATE?
is a one argument predicate applied to the (non-NIL) cost function computed
for the variable chosen to force next. If TERMINATE? returns T then the
variable reordering and forcing terminates. The following is a typical call
to REORDER used to solve numerical constraints:

(REORDER #'RANGE-SIZE
         #'(LAMBDA (X) (< X 1E-6))
         #'>
         #'DIVIDE-AND-CONQUER-FORCE)

The following is a typical call to REORDER used to solve symbolic constraints:

(REORDER #'DOMAIN-SIZE
         #'(LAMBDA (X) (DECLARE (IGNORE X)) NIL)
         #'<
         #'LINEAR-FORCE)

8. Instead of the standard Screamer file preamble which used to be:

(IN-PACKAGE :)
(USE-PACKAGE '(:LISP :SCREAMER))
(SHADOWING-IMPORT '(SCREAMER::DEFUN))

there is now a different standard preamble. Loading Screamer creates a
predefined package SCREAMER-USER which is useful for small student and
demonstration programs. If you wish your file to be in the SCREAMER-USER
package the single line:

(IN-PACKAGE :SCREAMER-USER)

should be placed at the top of the file. In addition:

(IN-PACKAGE :SCREAMER-USER)

should be typed to the Listener after loading Screamer. More complex programs
typically reside in their own package. You can place a program in its own
package by using the following preamble to your file:

(IN-PACKAGE :CL-USER)
(SCREAMER:DEFINE-SCREAMER-PACKAGE :
 )
(IN-PACKAGE :MY-PACKAGE)



Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 screamer

Maintainer

Nikodemus Siivola <nikodemus@random-state.net>

Author

Jeffrey Mark Siskind & David Allen McAllester

License

MIT

Description

Nondeterministic programming and constraint propagation.

Version

4.0.0

Source

screamer.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 screamer.asd

Location

screamer.asd

Systems

screamer (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 screamer/package.lisp

Parent

screamer (system)

Location

package.lisp

Packages

screamer


Previous: , Up: Lisp files   [Contents][Index]

3.1.3 screamer/screamer.lisp

Dependency

package.lisp (file)

Parent

screamer (system)

Location

screamer.lisp

Packages

screamer-user

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 screamer

Source

package.lisp (file)

Use List

common-lisp

Used By List

screamer-user

Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.2 screamer-user

Source

screamer.lisp (file)

Use List

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *dynamic-extent?*

Set to T to enable the dynamic extent optimization, NIL to disable it. Default is platform dependent.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *iscream?*

T if Screamer is running under ILisp/GNUEmacs with iscream.el loaded.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *maximum-discretization-range*

Discretize integer variables whose range is not greater than this number. Discretize all integer variables if NIL. Must be an integer or NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *minimum-shrink-ratio*

Ignore propagations which reduce the range of a variable by less than this ratio.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *screamer-version*

The version of Screamer which is loaded.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *strategy*

Strategy to use for FUNCALLV and APPLYV. Either :GFC for Generalized Forward Checking, or :AC for Arc Consistency. Default is :GFC.

Package

screamer

Source

screamer.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: all-values &body BODY

Evaluates BODY as an implicit PROGN and returns a list of all of the nondeterministic values yielded by the it.

These values are produced by repeatedly evaluating the body and backtracking to produce the next value, until the body fails and yields no further values.

Accordingly, local side effects performed by the body while producing each value are undone before attempting to produce subsequent values, and all local side effects performed by the body are undone upon exit from ALL-VALUES.

Returns a list containing NIL if BODY is empty.

An ALL-VALUES expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the ALL-VALUES appears in, the BODY is always in a nondeterministic context. An ALL-VALUES expression itself is always deterministic.

ALL-VALUES is analogous to the ‘bagof’ primitive in Prolog.

Package

screamer

Source

screamer.lisp (file)

Macro: assert! X

Restricts X to T. No meaningful result is returned. The argument X can be either a variable or a non-variable.

This assertion may cause other assertions to be made due to noticers attached to X.

A call to ASSERT! fails if X is known not to equal T prior to the assertion or if any of the assertions performed by the noticers result in failure.

Except for the fact that one cannot write #’ASSERT!, ASSERT! behaves like a function, even though it is implemented as a macro.

The reason it is implemented as a macro is to allow a number of compile time optimizations. Expressions like (ASSERT! (NOTV X)), (ASSERT! (NUMBERPV X)) and (ASSERT! (NOTV (NUMBERV X))) are transformed into calls to functions internal to Screamer which eliminate the need to create the boolean variable(s) normally returned by functions like NOTV and NUMBERPV. Calls to the functions NUMBERPV, REALPV, INTEGERPV, MEMBERV, BOOLEANPV, =V, <V, <=V, >V, >=V, /=V, NOTV, FUNCALLV, APPLYV and EQUALV which appear directly nested in a call to ASSERT!, or directly nested in a call to NOTV which is in turn directly nested in a call to ASSERT!, are similarly transformed.

Package

screamer

Source

screamer.lisp (file)

Macro: best-value FORM1 OBJECTIVE-FORM &optional FORM2

First evaluates OBJECTIVE-FORM, which should evaluate to constraint variable V.

Then repeatedly evaluates FORM1 in non-deterministic context till it fails. If previous round of evaluation produced an upper bound B for V, the during the next round any change to V must provide an upper bound higher than B, or that that change fails.

If the last successful evaluation of FORM produced an upper bound for V, returns a list of two elements: the the primary value of FORM1 from that round, and the upper bound of V.

Otherwise if FORM2 is provided, returns the result of evaluating it, or else calls fails.

Note: this documentation string is entirely reverse-engineered. Lacking information on just how BEST-VALUE was intended to work, it is hard to tell what is a bug, an accident of implementation, and what is a feature. If you have any insight into BEST-VALUE, please send email to nikodemus@random-state.net.

Package

screamer

Source

screamer.lisp (file)

Macro: count-failures &body BODY

Executes BODY keeping track of the number of times FAIL has been called without unwinding from BODY. After BODY completes, reports the number of failures to *STANDARD-OUTPUT* before returning values from BODY.

Package

screamer

Source

screamer.lisp (file)

Macro: decide X

Restricts X to a be boolean. After X is restricted a nondeterministic choice is made. For one branch, X is restricted to equal T and (DECIDE X) returns T as a result. For the other branch, X is restricted to equal NIL and (DECIDE X) returns NIL as a result. The argument X can be either a variable or a non-variable.

The initial restriction to boolean may cause other assertions to be made due to noticers attached to X. A call to DECIDE immediately fails if X is known not to be boolean prior to the assertion or if any of the assertions performed by the noticers result in failure.

Restricting X to be boolean attaches a noticer on X so that any subsequent assertion which restricts X to be non-boolean will fail.

Except for implementation optimizations (DECIDE X) is equivalent to:

(EITHER (PROGN (ASSERT! X) T) (PROGN (ASSERT! (NOTV X)) NIL))

Except for the fact that one cannot write #’DECIDE, DECIDE behaves like a function, even though it is implemented as a macro.

The reason it is implemented as a macro is to allow a number of compile time optimizations. Expressions like (DECIDE (NOTV X)), (DECIDE (NUMBERPV X)) and (DECIDE (NOTV (NUMBERPV X))) are transformed into calls to functions internal to Screamer which eliminate the need to create the boolean variable(s) normally returned by functions like notv and numberv. Calls to the functions NUMBERPV, REALPV, INTEGERPV, MEMBERPV, BOOLEANPV, =V, <V, <=V, >V, >=V, /=V, NOTV, FUNCALLV, APPLYV and EQUALV which appear directly nested in a call to decide, or directly nested in a call to NOTV which is in turn directly nested in a call to decide, are similarly transformed.

Package

screamer

Source

screamer.lisp (file)

Macro: define-screamer-package DEFINED-PACKAGE-NAME &body OPTIONS

Convenience wrapper around DEFPACKAGE. Passes its argument directly
to DEFPACKAGE, and automatically injects two additional options:

(:shadowing-import-from :screamer :defun :multiple-value-bind :y-or-n-p) (:use :cl :screamer)

Package

screamer

Source

screamer.lisp (file)

Macro: either &body ALTERNATIVES

Nondeterministically evaluates and returns the value of one of its ALTERNATIVES.

EITHER takes any number of arguments. With no arguments, (EITHER) is equivalent to (FAIL) and is thus deterministic. With one argument, (EITHER X) is equivalent to X itself and is thus deterministic only when X is deterministic. With two or more argument it is nondeterministic and can only appear in a nondeterministic context.

It sets up a choice-point and evaluates the first ALTERNATIVE returning its values. When backtracking follows to this choice-point, the next ALTERNATIVE is evaluated and its values are returned. When no more ALTERNATIVES remain, the current choice-point is removed and backtracking continues to the next most recent choice-point.

Package

screamer

Source

screamer.lisp (file)

Macro: for-effects &body BODY

Evaluates BODY as an implicit PROGN in a nondeterministic context and returns NIL.

The body is repeatedly backtracked to its first choice-point until the body fails.

Local side effects performed by BODY are undone when FOR-EFFECTS returns.

A FOR-EFFECTS expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the FOR-EFFECTS appears in, BODY are always in a nondeterministic context. A FOR-EFFECTS expression is is always deterministic.

Package

screamer

Source

screamer.lisp (file)

Macro: global &body BODY

Evaluates BODY in the same fashion as PROGN except that all SETF and SETQ forms lexically nested in its body result in global side effects which are not undone upon backtracking.

Note that this affects only side effects introduced explicitly via SETF and SETQ. Side effects introduced by Common Lisp builtin functions such as RPLACA are always global anyway.

LOCAL and GLOBAL may be nested inside one another. The nearest lexically surrounding one determines whether or not a given SETF or SETQ results in a local or global side effect.

Side effects default to be global when there is no surrounding LOCAL or GLOBAL expression. Global side effects can appear both in deterministic as well as nondeterministic contexts. In nondeterministic contexts, GLOBAL as well as SETF are treated as special forms rather than macros. This should be completely transparent to the user.

Package

screamer

Source

screamer.lisp (file)

Macro: ith-value I FORM &optional DEFAULT

Returns the Ith nondeterministic value yielded by FORM.

I must be an integer. The first nondeterministic value yielded by FORM is numbered zero, the second one, etc. The Ith value is produced by repeatedly evaluating FORM, backtracking through and discarding the first I values and deterministically returning the next value produced.

No further execution of FORM is attempted after it successfully yields the desired value.

If FORM fails before yielding both the I values to be discarded, as well as the desired Ith value, then DEFAULT is evaluated and its value returned instead. DEFAULT defaults to (FAIL) if not present.

Local side effects performed by FORM are undone when ITH-VALUE returns, but local side effects performed by DEFAULT and by I are not undone when ITH-VALUE returns.

An ITH-VALUE expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the ITH-VALUE appears in, FORM is always in a nondeterministic context, while DEFAULT and I are in whatever context the ITH-VALUE appears in.

An ITH-VALUE expression is nondeterministic if DEFAULT is present and is nondeterministic, or if I is nondeterministic. Otherwise it is deterministic.

If DEFAULT is present and nondeterministic, and if FORM fails, then it is possible to backtrack into the DEFAULT and for the ITH-VALUE expression to nondeterministically return multiple times.

If I is nondeterministic then the ITH-VALUE expression operates nondeterministically on each value of I. In this case, backtracking for each value of FORM and DEFAULT is nested in, and restarted for, each backtrack of I.

Package

screamer

Source

screamer.lisp (file)

Macro: known? X

Restricts X to be a boolean. If X is equal to T after being restricted to be boolean, returns T. If X is equal to NIL or if the value of X is unknown returns NIL. The argument X can be either a variable or a non-variable.

The initial restriction to boolean may cause other assertions to be made due to noticers attached to X. A call to KNOWN? fails if X is known not to be boolean prior to the assertion or if any of the assertions performed by the noticers result in failure.

Restricting X to be boolean attaches a noticer on X so that any subsequent assertion which restricts X to be non-boolean will fail.

Except for the fact that one cannot write #’KNOWN?, KNOWN? behaves like a function, even though it is implemented as a macro.

The reason it is implemented as a macro is to allow a number of compile time optimizations. Expressions like (KNOWN? (NOTV X)), (KNOWN? (NUMBERPV X)) and (KNOWN? (NOTV (NUMBERPV X))) are transformed into calls to functions internal to Screamer which eliminate the need to create the boolean variable(s) normally returned by functions like NOTV and NUMBERV. Calls to the functions NUMBERPV, REALPV, INTEGERPV, MEMBERV, BOOLEANPV, =V, <V, <=V, V, >=v, /=v, NOTV, FUNCALLV, APPLYV and EQUALV which appear directly nested in a call to KNOWN?, or directly nested in a call to NOTV which is in turn directly nested in a call to KNOWN?, are similarly transformed.

Package

screamer

Source

screamer.lisp (file)

Macro: local &body BODY

Evaluates BODY in the same fashion as PROGN except that all SETF and SETQ forms lexically nested in its body result in local side effects which are undone upon backtracking.

This affects only side effects introduced explicitly via SETF and SETQ. Side effects introduced by either user defined functions or builtin Common Lisp functions such as RPLACA are always global.

Behaviour of side effects introduced by macro-expansions such as INCF depends on the exact macro-expansion. If (INCF (FOO)) expands using eg. SET-FOO, LOCAL is unable to undo the side-effect.

LOCAL cannot distinguish between initially uninitialized and intialized places, such as unbound variables or hash-table keys with no prior values. As a result, an attempt to assign an unbound variable inside LOCAL will signal an error due to the system’s attempt to first read the variable. Similarly, undoing a (SETF GETHASH) when the key did not previously exist in the table will insert a NIL into the table instead of doing a REMHASH. Easiest way to work around this is by using TRAIL.

LOCAL and GLOBAL may be nested inside one another. The nearest lexically surrounding one determines whether or not a given SETF or SETQ results in a local or global side effect.

Side effects default to be global when there is no surrounding LOCAL or GLOBAL expression. Local side effects can appear both in deterministic as well as nondeterministic contexts though different techniques are used to implement the trailing of prior values for restoration upon backtracking. In nondeterministic contexts, LOCAL as well as SETF are treated as special forms rather than macros. This should be completely transparent to the user.

Package

screamer

Source

screamer.lisp (file)

Macro: local-output &body FORMS

Currently unsupported.

When running under ILisp with iscream.el loaded, does non-determinism aware output to Emacs, which will be deleted when the current choice is unwound.

Package

screamer

Source

screamer.lisp (file)

Macro: necessarily? &body BODY

Evaluates BODY as an implicit PROGN in nondeterministic context,
returning true if the body never yields false.

The body is repeatedly backtracked as long as it yields true. Returns the last true value yielded by the body if it fails before yielding NIL, otherwise returns NIL.

Local side effects performed by the body are undone when NECESSARILY? returns.

A NECESSARILY? expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the NECESSARILY? appears in, its body is always in a nondeterministic context. A NECESSARILY? expression is always deterministic.

Package

screamer

Source

screamer.lisp (file)

Macro: one-value FORM &optional DEFAULT

Returns the first nondeterministic value yielded by FORM.

No further execution of FORM is attempted after it successfully returns one value.

If FORM does not yield any nondeterministic values (i.e. it fails) then DEFAULT is evaluated and its value returned instead. DEFAULT defaults to (FAIL) if not present.

Local side effects performed by FORM are undone when ONE-VALUE returns, but local side effects performed by DEFAULT are not undone when ONE-VALUE returns.

A ONE-VALUE expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the ONE-VALUE appears in, FORM is always in a nondeterministic context, while DEFAULT is in whatever context the ONE-VALUE form appears.

A ONE-VALUE expression is nondeterministic if DEFAULT is present and is nondeterministic, otherwise it is deterministic.

If DEFAULT is present and nondeterministic, and if FORM fails, then it is possible to backtrack into the DEFAULT and for the ONE-VALUE form to nondeterministically return multiple times. ONE-VALUE is analogous to the cut primitive (‘!’) in Prolog.

Package

screamer

Source

screamer.lisp (file)

Macro: possibly? &body BODY

Evaluates BODY as an implicit PROGN in nondeterministic context, returning true if the body ever yields true.

The body is repeatedly backtracked as long as it yields NIL. Returns
the first true value yielded by the body, or NIL if body fails before yielding true.

Local side effects performed by the body are undone when POSSIBLY? returns.

A POSSIBLY? expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the POSSIBLY? appears in, its body is always in a nondeterministic context. A POSSIBLY? expression is always deterministic.

Package

screamer

Source

screamer.lisp (file)

Macro: print-values &body BODY

Evaluates BODY as an implicit PROGN and prints each of the nondeterministic values yielded by it using PRINT.

After each value is printed, the user is queried as to whether or not further values are desired. These values are produced by repeatedly evaluating the body and backtracking to produce the next value, until either the user indicates that no further values are desired or until the body fails and yields no further values.

Returns the last value printed.

Accordingly, local side effects performed by the body while producing each value are undone after printing each value, before attempting to produce subsequent values, and all local side effects performed by the body are undone upon exit from PRINT-VALUES, either because there are no further values or because the user declines to produce further values.

A PRINT-VALUES expression can appear in both deterministic and nondeterministic contexts. Irrespective of what context the PRINT-VALUES appears in, the BODY are always in a nondeterministic context. A PRINT-VALUES expression itself is always deterministic.

PRINT-VALUES is analogous to the standard top-level user interface in Prolog.

Package

screamer

Source

screamer.lisp (file)

Macro: when-failing (&body FAILING-FORMS) &body BODY

Whenever FAIL is called during execution of BODY, executes FAILING-FORMS before unwinding.

Package

screamer

Source

screamer.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: *v &rest XS

Constrains its arguments to be numbers. If called with no arugments, returns 1. If called with a single argument, returns its value. If called with more than two arguments, behaves as nested sequence of two-argument calls:

(*V X1 X2 ... Xn) = (*V X1 (*V X2 (*V ...)))

When called with two arguments, if both arguments are bound, returns the product of their values. If either argument is known to equal zero, returns zero. If either argument is known to equal one, returns the value of the other. Otherwise returns number variable V.

* Product of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes known that cannot be true, FAIL is called.

* If both arguments are known to be reals, V is constrained to be real.

* If both arguments are known to be integers, V is constained to be integer.

* If V is known to be an integer, and either X1 or X2 is known to be real, both X1 and X2 are constrained to be integers.

* If V is known to be an reals, and either X1 or X2 is known to be real, both X1 and X2 are constrained to be reals.

Note: Numeric contagion rules of Common Lisp are not applied if either argument equals zero or one.

Package

screamer

Source

screamer.lisp (file)

Function: +v &rest XS

Constrains its arguments to be numbers. Returns 0 if called with no arguments. If called with a single argument, returns its value. If called with more than two arguments, behaves as nested sequence of two-argument calls:

(+V X1 X2 ... Xn) = (+V X1 (+V X2 (+V ...)))

When called with two arguments, if both arguments are bound, returns the sum of their values. If either argument is known to be zero, returns the value of the remaining argument. Otherwise returns number variable V.

* Sum of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes known that cannot be true, FAIL is called.

* If both arguments are known to be reals, V is constrained to be real.

* If both arguments are known to be integers, V is constained to be integer.

* If one argument is known to be a non-integer, and the other is known to be a real, V is constrained to be a non-integer.

* If one argument is known to be a non-real, and the other is known
to be a real, V is constrained to be non-real.

Note: Numeric contagion rules of Common Lisp are not applied if either argument equals zero.

Package

screamer

Source

screamer.lisp (file)

Function: -v X &rest XS

Constrains its arguments to be numbers. If called with a single argument, behaves as if the two argument call:

(-V 0 X)

If called with more than two arguments, behaves as nested sequence of two-argument calls:

(-V X1 X2 ... Xn) = (-V X1 (-V X2 (-V ...)))

When called with two arguments, if both arguments are bound, returns the difference of their values. If X2 is known to be zero, returns the value of X1. Otherwise returns number variable V.

* Difference of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes known that cannot be true, FAIL is called.

* If both arguments are known to be reals, V is constrained to be real.

* If both arguments are known to be integers, V is constained to be integer.

* If one argument is known to be a non-integer, and the other is known to be a real, V is constrained to be a non-integer.

* If one argument is known to be a non-real, and the other is known
to be a real, V is constrained to be non-real.

Note: Numeric contagion rules of Common Lisp are not applied if X2 equals zero.

Package

screamer

Source

screamer.lisp (file)

Function: /=v X &rest XS

Returns a boolean value which is constrained to be T if no two arguments are numerically equal, and constrained to be NIL if any two or more arguments are numerically equal.

This function takes one or more arguments. All of the arguments are restricted to be numeric.

Returns T when called with one argument. A call such as (/=V X1 X2 ... Xn) with more than two arguments behaves like a conjunction of two argument calls:

(ANDV (/=V X1 X2) ... (/=V X1 Xn)
(/=V X2 X3) ... (/=V X2 Xn)
...
(/=V Xi Xi+1 ... (/=V Xi Xn)
...
(/=V Xn-1 xn))

When called with two arguments, returns T if X1 is known not to be equal to X2 at the time of call, NIL if X1 is known to be equal to X2 at the time of call, and otherwise a new boolean variable V.

Two numeric values are known not to be equal when their domains are disjoint.

Two real values are known not to be equal when their ranges are disjoint, i.e. the upper bound of one is greater than the lower bound of the other.

Two numeric values are known to be equal only when they are both bound and equal according to the Common Lisp function =.

When a new variable is created, the values of X1, X2 and V are mutually constrained via noticers so that V is equal to T if and only if X1 is known not to be equal to X2 and V is equal to NIL if and only if X1 is known to be equal to X2.

* If it later becomes known that X1 is not equal to X2, noticers attached to X1 and X2 restrict V to equal T. Likewise, if it later becomes known that X1 is equal to X2, noticers attached to X1 and X2 restrict V to equal NIL.

* If V ever becomes known to equal T then a noticer attached to V restricts X1 to not be equal to X2. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X1 to be equal to X2.

Restricting two values X1 and X2 to be equal is performed by attaching noticers to X1 and X2. These noticers continually restrict the domains of X1 and X2 to be equivalent sets (using the Common Lisp function = as a test function) as their domains are restricted. Furthermore, if X1 is known to be real then the noticer attached to X2 continually restrict the upper bound of X1 to be no higher than the upper bound of X2 and the lower bound of X1 to be no lower than the lower bound of X2. The noticer of X2 performs a symmetric restriction on the bounds of X1 if it is known to be real.

Restricting two values X1 and X2 to not be equal is also performed by attaching noticers to X1 and X2. These noticers however, do not restrict the domains or ranges of X1 or X2. They simply monitor their continually restrictions and fail when any assertion causes X1 to be known to be equal to X2.

Package

screamer

Source

screamer.lisp (file)

Function: /v X &rest XS

Constrains its arguments to be numbers. If called with a single argument, behaves as the two argument call:

(/V 1 X)

If called with more than two arguments, behaves as nested sequence of two-argument calls:

(/V X1 X2 ... Xn) = (/V ... (/V (/V X1 X2) X3) ... Xn)

When called with two arguments, if both arguments are bound, returns the division of their values. If X1 is known to equal zero, returns 0. If X2 is known to equal zero, FAIL is called. If X2 is known to equal one, returns the value of X1. Otherwise returns number variable V.

* Division of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes known that cannot be true, FAIL is called.

* If both arguments are known to be reals, V is constrained to be real.

* If both arguments are known to be integers, V is constained to be integer.

* If V is known to be an integer, and either X1 or X2 is known to be real, both X1 and X2 are constrained to be integers.

* If V is known to be an reals, and either X1 or X2 is known to be real, both X1 and X2 are constrained to be reals.

Note: Numeric contagion rules of Common Lisp are not applied if X1 equals zero or X2 equals one.

Package

screamer

Source

screamer.lisp (file)

Function: <=v X &rest XS

All arguments are constrained to be real. Returns T when called with one
argument. A call such as (<=V X1 X2 ... Xn) with more than two arguments
behaves like a conjunction of two argument calls:

(ANDV (<=V X1 X2) ... (<=V Xi Xi+1) ... (<=V Xn-1 Xn))

When called with two arguments, returns T if X1 is know to be less than or equal to X2 at the time of the call, NIL if X1 is known to be greater than X2, and otherwise a new boolean variable V.

Values of V, X1, and X2 are mutually constrained:

* V is equal to T iff X1 is known to be less than or equal to X2.

* V is equal to NIL iff X2 is known to be greater than X2.

* If V is known to be T, X1 is constrained to be less than or equal to X2.

* If V is known to be NIL, X1 is constrained to be greater than X2.

Package

screamer

Source

screamer.lisp (file)

Function: <v X &rest XS

Returns a boolean value which is constrained to be T if each argument Xi is less than the following argument Xi+1 and constrained to be NIL if some argument Xi is greater than or equal to the following argument Xi+1.

This function takes one or more arguments. All of the arguments are restricted to be real.

Returns T when called with one argument. A call such as (<V X1 X2 ... Xn) with more than two arguments behaves like a conjunction of two argument calls:

(ANDV (<V X1 X2) ... (<V Xi Xi+1 ) ... (<V Xn-1 Xn))

When called with two arguments, returns T if X1 is known to be less than X2 at the time of call, NIL if X1 is known to be greater than or equal to X2 at the time of call, and otherwise a new boolean variable V.

A real value X1 is known to be less than a real value X2 if X1 has an upper bound, X2 has a lower bound and the upper bound of X1 is less than the lower bound of X2.

A real value X1 is known to be greater than or equal to a real value X2 if X1 has a lower bound, X2 has an upper bound and the lower bound of X1 is greater than or equal to the upper bound of X2.

When a new variable is created, the values of X1, X2 and v are mutually constrained via noticers so that V is equal to T if and only if X1 is known to be less than X2 and V is equal to NIL if and only if X1 is known to be greater than or equal to X2.

* If it later becomes known that X1 is less than X2, noticers attached to X1 and X2 restrict V to equal T. Likewise, if it later becomes known that X1 is greater than or equal to X2, noticers attached to X1 and X2 restrict V to equal NIL.

* If V ever becomes known to equal T then a noticer attached to V restricts X1 to be less than X2. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X1 to be greater than or equal to X2.

Restricting a real value X1 to be less than a real value X2 is performed by attaching noticers to X1 and X2. The noticer attached to X1 continually restricts the lower bound of X2 to be no lower than the upper bound of X1 if X1 has an upper bound. The noticer attached to X2 continually restricts the upper bound of X1 to be no higher than the lower bound of X2 if X2 has a lower bound. Since these restrictions only guarantee that X1 be less than or equal to X2, the constraint that X1 be strictly less than X2 is enforced by having the noticers fail when both X1 and X2 become known to be equal.

Restricting a real value X1 to be greater than or equal to a real value X2 is performed by an analogous set of noticers without this last equality check.

Package

screamer

Source

screamer.lisp (file)

Function: =v X &rest XS

Returns a boolean value which is constrained to be T if all of the arguments are numerically equal, and constrained to be NIL if two or more of the arguments numerically differ.

This function takes one or more arguments. All of the arguments are restricted to be numeric.

Returns T when called with one argument. A call such as (=V X1 X2 ... Xn) with more than two arguments behaves like a conjunction of two argument calls:

(ANDV (=V X1 X2) ... (=V Xi Xi+1) ... (=V Xn-1 Xn))

When called with two arguments, returns T if X1 is known to be equal to X2 at the time of call, NIL if X1 is known not to be equal to X2 at the time of call, and a new boolean variable V if is not known if the two values are equal.

Two numeric values are known to be equal only when they are both bound and equal according to the Common Lisp function =.

Two numeric values are known not to be equal when their domains are disjoint. Furthermore, two real values are known not to be equal when their ranges are disjoint, i.e. the upper bound of one is greater than the lower bound of the other.

When a new variable is created, the values of X1, X2, and V are mutually constrained via noticers so that V is equal to T if and only if X1 is known to be equal to X2, and V is equal to NIL if and only if X1 is known not to be equal to X2.

* If it later becomes known that X1 is equal to X2 noticers attached to X1 and X2 restrict V to equal T. Likewise if it later becomes known that X1 is not equal to X2 noticers attached to X1 and X2 restrict V to equal NIL.

* If V ever becomes known to equal T then a noticer attached to V restricts X1 to be equal to X2. Likewise if V ever becomes known to equal NIL then a noticer attached to V restricts X1 not to be equal to X2.

* If X1 is known to be real then the noticer attached to X2 continually restrict the upper bound of X1 to be no higher than the upper bound of X2 and the lower bound of X1 to be no lower than the lower bound of X2. Likewise for bounds of X1 if X2 is known to be real.

Restricting two values x1 and x2 to be equal is performed by attaching noticers to x1 and x2. These noticers continually restrict the domains of x1 and x2 to be equivalent sets (using the Common Lisp function = as a test function) as their domains are restricted.

Restricting two values X1 and X2 to not be equal is also performed by attaching noticers to X1 and X2. These noticers however do not restrict the domains or ranges of X1 or X2. They simply monitor their continually restrictions and fail when any assertion causes X1 to be known to be equal to X2.

Package

screamer

Source

screamer.lisp (file)

Function: >=v X &rest XS

All arguments are constrained to be real. Returns T when called
with one argument. A call such as (>=V X1 X2 ... Xn) with more than two arguments behaves like a conjunction of two argument calls:

(ANDV (>=V X1 X2) ... (>=V Xi Xi+1) ... (>=V Xn-1 Xn))

When called with two arguments, returns T if X1 is know to be greater than or equal to X2 at the time of the call, NIL if X1 is known to be less than X2, and otherwise a new boolean variable V.

Values of V, X1, and X2 are mutually constrained:

* V is equal to T iff X1 is known to be greater than or equal to X2.

* V is equal to NIL iff X2 is know to be less than X2.

* If V is known to be T, X1 is constrained to be greater than or equal to X2.

* If V is known to be NIL, X1 is constrained to be less than X2.

Package

screamer

Source

screamer.lisp (file)

Function: >v X &rest XS

All arguments are constrained to be real. Returns T when called with one argument. A call such as (>V X1 X2 ... Xn) with more than two arguments behaves like a conjunction of two argument calls:

(ANDV (> X1 X2) ... (> Xi Xi+1) ... (> Xn-1 Xn))

When called with two arguments, returns T if X1 is know to be greater than X2 at the time of the call, NIL if X1 is known to be less than or equal to X2, and otherwise a new boolean variable V.

Values of V, X1, and X2 are mutually constrained:

* V is equal to T iff X1 is known to be greater than X2.

* V is equal to NIL iff X2 is known to be less than or equal to X2.

* If V is known to be T, X1 is constrained to be greater than X2.

* If V is known to be NIL, X1 is constrained to be less than or equal to X2.

Package

screamer

Source

screamer.lisp (file)

Function: a-boolean ()

Equivalent to (EITHER T NIL).

Package

screamer

Source

screamer.lisp (file)

Function: a-booleanv &optional NAME

Returns a boolean variable.

Package

screamer

Source

screamer.lisp (file)

Function: a-member-of SEQUENCE

Nondeterministically returns an element of SEQUENCE. The elements are returned in the order that they appear in SEQUENCE. The SEQUENCE must be either a list or a vector.

Package

screamer

Source

screamer.lisp (file)

Function: a-member-ofv VALUES &optional NAME

Returns a variable whose value is constrained to be one of VALUES. VALUES can be either a vector or a list designator.

Package

screamer

Source

screamer.lisp (file)

Function: a-numberv &optional NAME

Returns a variable whose value is constained to be a number.

Package

screamer

Source

screamer.lisp (file)

Function: a-real-abovev LOW &optional NAME

Returns a real variable whose value is constrained to be greater than or equal to LOW.

Package

screamer

Source

screamer.lisp (file)

Function: a-real-belowv HIGH &optional NAME

Returns a real variable whose value is constrained to be less than or equal to HIGH.

Package

screamer

Source

screamer.lisp (file)

Function: a-real-betweenv LOW HIGH &optional NAME

Returns a real variable whose value is constrained to be greater than or equal to low and less than or equal to high. If the resulting real variable is bound, its value is returned instead. Fails if it is known that low is greater than high at the time of call.

The expression (A-REAL-BETWEENV LOW HIGH) is an abbreviation for:

(LET ((V (MAKE-VARIABLE)))
(ASSERT! (REALPV V))
(ASSERT! (>=V V LOW))
(ASSERT! (<=V V HIGH))
(VALUE-OF V))

Package

screamer

Source

screamer.lisp (file)

Function: a-realv &optional NAME

Returns a real variable.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer ()

Generator yielding integers in sequence 0, 1, -1, 2, -2, ...

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-above LOW

Generator yielding integers starting from LOW and continuing sequentially in increasing direction.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-abovev LOW &optional NAME

Returns an integer variable whose value is constrained to be greater than or equal to LOW.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-below HIGH

Generator yielding integers starting from HIGH and continuing sequentially in decreasing direction.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-belowv HIGH &optional NAME

Returns an integer variable whose value is constrained to be less than or equal to HIGH.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-between LOW HIGH

Nondeterministically returns an integer in the closed interval [LOW, HIGH]. The results are returned in ascending order. Both LOW and HIGH must be integers. Fails if the interval does not contain any integers.

Package

screamer

Source

screamer.lisp (file)

Function: an-integer-betweenv LOW HIGH &optional NAME

Returns an integer variable whose value is constrained to be greater than or equal to LOW and less than or equal to HIGH. If the resulting integer variable is bound, its value is returned instead. Fails if it is known that there is no integer between LOW and HIGH at the time of call.

The expression (AN-INTEGER-BETWEENV LOW HIGH) is an abbreviation for:

(LET ((V (MAKE-VARIABLE)))
(ASSERT! (INTEGERPV V))
(ASSERT! (>=V V LOW))
(ASSERT! (<=V V HIGH))
(VALUE-OF v))

Package

screamer

Source

screamer.lisp (file)

Function: an-integerv &optional NAME

Returns an integer variable.

Package

screamer

Source

screamer.lisp (file)

Function: andv &rest XS

Restricts each argument to be boolean.

Returns T if called with no arguments, or if all arguments are known to equal T after being restricted to be boolean, and returns NIL if any argument is known to equal NIL after this restriction.

Otherwise returns a boolean variable V. The values of the arguments and V are mutually constrained:

* If any argument is later known to equal NIL value of V becomes NIL.

* If all arguments are later known to equal T, value of V becomes T.

* If value of V is later known to equal T, all arguments become T.

* If value of V is later known to equal NIL, and all but one argument is known to be T, the remaining argument becomes NIL.

Note that unlike CL:AND, ANDV is a function and always evaluates all its arguments. Secondly, any non-boolean argument causes it to fail.

Package

screamer

Source

screamer.lisp (file)

Function: apply-nondeterministic FUNCTION &rest ARGUMENTS

Analogous to the CL:APPLY, except FUNCTION can be either a nondeterministic function, or an ordinary deterministic function.

You must use APPLY-NONDETERMINISTIC to apply a nondeterministic function. An error is signalled if a nondeterministic function object is used with CL:APPLY.

You can use APPLY-NONDETERMINISTIC to apply either a deterministic or nondeterministic function, though even if all of the ARGUMENTS are deterministic and FUNCTION is a deterministic function object, the call expression will still be nondeterministic (with presumably a single value), since it is impossible to determine at compile time that a given call to APPLY-NONDETERMINISTIC will be passed only deterministic function objects for function.

Package

screamer

Source

screamer.lisp (file)

Function: apply-substitution X

If X is a CONS, or a variable whose value is a CONS, returns
a freshly consed copy of the tree with all variables dereferenced. Otherwise returns the value of X.

Package

screamer

Source

screamer.lisp (file)

Function: applyv F X &rest XS

F must be a deterministic function. If all arguments X are bound, returns the result of calling F on the dereferenced values of spread arguments.

Otherwise returns a fresh variable V, constrained to be equal to the result of calling F on the dereferenced values of arguments.

Additionally, if all but one of V and the argument variables become known, and the remaining variable has a finite domain, then that domain is further restricted to be consistent with other arguments.

Package

screamer

Source

screamer.lisp (file)

Function: booleanp X

Returns true iff X is T or NIL.

Package

screamer

Source

screamer.lisp (file)

Function: booleanpv X

The expression (BOOLEANPV X) is an abbreviation for (MEMBERV X ’(T NIL)).

Package

screamer

Source

screamer.lisp (file)

Function: bound? X

Returns T if X is not a variable or if X is a bound variable. Otherwise returns NIL. BOUND? is analogous to the extra-logical predicates ‘var’ and ‘nonvar’ typically available in Prolog.

Package

screamer

Source

screamer.lisp (file)

Function: count-trues &rest XS

Returns the number of time a non-NIL value occurs in its arguments.

Package

screamer

Source

screamer.lisp (file)

Function: count-truesv &rest XS

Constrains all its arguments to be boolean. If each argument is known, returns
the number of T arguments. Otherwise returns a fresh constraint variable V.

V and arguments are mutually constrained:

* Lower bound of V is the number arguments known to be T.

* Upper bound of V is the number arguments minus the number of arguments known to be NIL.

* If lower bound of V is constrained to be equal to number of arguments known
to be NIL, all arguments not known to be NIL are constrained to be T.

* If Upper bound of V is constrained to be equal to number of arguments known
to be T, all arguments not known to be T are constrained to be NIL.

Package

screamer

Source

screamer.lisp (file)

Function: divide-and-conquer-force VARIABLE

Returns X if X is not a variable. If X is a bound variable then returns its value. Otherwise implements a single binary-branching step of a divide-and-conquer search algorithm. There are always two alternatives, the second of which is tried upon backtracking.

If it is known to have a finite domain D then this domain is split into two halves and the value of X is nondeterministically restricted to be a member one of the halves. If X becomes bound by this restriction then its value is returned. Otherwise, X itself is returned.

If X is not known to have a finite domain but is known to be real and to have both lower and upper bounds then nondeterministically either the lower or upper bound is restricted to the midpoint between the lower and upper bound. If X becomes bound by this restriction then its dereferenced value is returned. Otherwise, X itself is returned.

An error is signalled if X is not known to be restricted to a finite domain and either is not known to be real or is not known to have both a lower and upper bound.

When the set of potential values may be infinite, users of DIVIDE-AND-CONQUER-FORCE may need to take care to fail when the range size of the variable becomes too small, unless other constraints on it are sufficient to guarentee failure.

The method of splitting the domain into two halves is left unspecified to give future implementations leeway in incorporating heuristics in the process of determining a good search order. All that is specified is that if the domain size is even prior to splitting, the halves are of equal size, while if the domain size is odd, the halves differ in size by at most one.

Package

screamer

Source

screamer.lisp (file)

Function: domain-size X

Returns the domain size of X.

If X is an integer variable with an upper and lower bound, its domain size is the one greater than the difference of its bounds. Eg. [integer 1:2] has domain size 2.

If X is a variable with an enumerated domain, its domain size is the size of that domain.

If X is a CONS, or a variable whose value is a CONS, its domain size is the product of the domain sizes of its CAR and CDR.

Other types of unbound variables have domain size NIL, whereas non-variables have domain size of 1.

Package

screamer

Source

screamer.lisp (file)

Function: equalv X Y

Returns T if the aggregate object X is known to equal the aggregate object Y, NIL if the aggregate object X is known not to equal the aggregate object Y, and a new boolean variable V if it is not known whether or not X equals Y when EQUALV is called.

The values of X, Y and V are mutually constraints via noticers so that V equals T if and only if X is known to equal Y and V equals NIL if and only if X is known not to equal Y.

Noticers are attached to V as well as to all variables nested in both in X and Y. When the noticers attached to variables nested in X and Y detect that X is known to equal Y they restrict V to equal T. Likewise, when the noticers attached to variables nested in X and Y detect that X is known not to equal Y they restrict V to equal NIL.

Furthermore, if V later becomes known to equal T then X and Y are unified. Likewise, if V later becomes known to equal NIL then X and Y are restricted to not be equal. This is accomplished by attaching noticers to the variables nested in X and Y which detect when X becomes equal to Y and fail.

The expression (KNOWN? (EQUALV X Y)) is analogous to the extra-logical predicate ‘==’ typically available in Prolog.

The expression (KNOWN? (NOTV (EQUALV X Y))) is analogous to the extra-logical predicate ‘\=’ typically available in Prolog.

The expression (ASSERT! (EQUALV X Y)) is analogous to Prolog unification.

The expression (ASSERT! (NOTV (EQUALV X Y))) is analogous to the disunification operator available in Prolog-II.

Package

screamer

Source

screamer.lisp (file)

Function: fail ()

Backtracks to the most recent choice-point.

FAIL is deterministic function and thus it is permissible to reference #’FAIL, and write (FUNCALL #’FAIL) or (APPLY #’FAIL).

Calling FAIL when there is no choice-point to backtrack to signals an error.

Package

screamer

Source

screamer.lisp (file)

Function: funcall-nondeterministic FUNCTION &rest ARGUMENTS

Analogous to CL:FUNCALL, except FUNCTION can be either a nondeterministic function, or an ordinary determinisitic function.

You must use FUNCALL-NONDETERMINISTIC to funcall a nondeterministic function. An error is signalled if you attempt to funcall a nondeterministic function object with CL:FUNCALL.

You can use FUNCALL-NONDETERMINISTIC to funcall either a deterministic or nondeterministic function, though even if all of the ARGUMENTS are deterministic and FUNCTION is a deterministic function object, the call expression will still be nondeterministic (with presumably a single value), since it is impossible to determine at compile time that a given call to FUNCALL-NONDETERMINISTIC will be passed only deterministic function objects for function.

Package

screamer

Source

screamer.lisp (file)

Function: funcallv F &rest X

F must be a deterministic function. If all arguments X are bound, returns the result of calling F on the dereferenced values of arguments.

Otherwise returns a fresh variable V, constrained to be equal to the result of calling F on the dereferenced values of arguments.

Additionally, if all but one of V and the argument variables become known, and the remaining variable has a finite domain, then that domain is further restricted to be consistent with other arguments.

Package

screamer

Source

screamer.lisp (file)

Function: ground? X

The primitive GROUND? is an extension of the primitive BOUND? which can recursively determine whether an entire aggregate object is bound. Returns T if X is bound and either the value of X is atomic or a CONS tree where all atoms are bound.

Otherwise returns nil.

Package

screamer

Source

screamer.lisp (file)

Function: integerpv X

Returns T if X is known to be integer valued, and NIL if X is known be non-integer value.

If it is not known whether or not X is integer valued when INTEGERPV is called then INTEGERPV creates and returns a new boolean variable V.

The values of X and V are mutually constrained via noticers so that V is equal to T if and only if X is known to be integer valued, and V is equal to NIL if and only if X is known to be non-integer valued.

If X later becomes known to be integer valued, a noticer attached to X restricts V to equal T. Likewise, if X later becomes known to be non-integer valued, a noticer attached to X restricts V to equal NIL.

Furthermore, if V ever becomes known to equal T then a noticer attached to V restricts X to be integer valued. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X to be non-integer valued.

Package

screamer

Source

screamer.lisp (file)

Function: linear-force X

Returns X if it is not a variable. If X is a bound variable then returns its value.

If X is an unbound variable then it must be known to have a countable set of potential values. In this case X is nondeterministically restricted to be equal to one of the values in this countable set, thus forcing X to be bound. The dereferenced value of X is then returned.

An unbound variable is known to have a countable set of potential values either if it is known to have a finite domain or if it is known to be integer valued.

An error is signalled if X is not known to have a finite domain and is not known to be integer valued.

Upon backtracking X will be bound to each potential value in turn, failing when there remain no untried alternatives.

Since the set of potential values is required only to be countable, not finite, the set of untried alternatives may never be exhausted and backtracking need not terminate. This can happen, for instance, when X is known to be an integer but lacks either an upper of lower bound.

The order in which the nondeterministic alternatives are tried is left unspecified to give future implementations leeway in incorporating heuristics in the process of determining a good search order.

Package

screamer

Source

screamer.lisp (file)

Function: make-variable &optional NAME

Creates and returns a new variable. Variables are assigned a name which is only used to identify the variable when it is printed. If the parameter NAME is given then it is assigned as the name of the variable. Otherwise, a unique name is assigned. The parameter NAME can be any Lisp object.

Package

screamer

Source

screamer.lisp (file)

Function: maxv X &rest XS

Constrains its arguments to be real. If called with a single argument, returns its value. If called with multiple arguments, behaves as if a combination of two argument calls:

(MAXV X1 X2 ... Xn) == (MAXV (MAXV X1 X2) ... Xn)

If called with two arguments, and either is known to be greater than or equal to the other, returns the value of that argument. Otherwise returns a real variable V, mutually constrained with the arguments:

* Maximum of the values of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes know that cannot be true. FAIL is called.

* If both arguments are integers, V is constrained to be an integer.

Package

screamer

Source

screamer.lisp (file)

Function: memberv X SEQUENCE

Returns T if X is known to be a member of SEQUENCE (using the Common Lisp function EQL as a test function), NIL if X is known not to be a member of SEQUENCE, and otherwise returns a new boolean variable V.

When a new variable is created, the values of X and V are mutually constrained via noticers so that V is equal to T if and only if X is known to be a member of SEQUENCE and V is equal to NIL if and only if X is known not to be a member of SEQUENCE.

* If X later becomes known to be a member of SEQUENCE, a noticer attached to X restricts v to equal T. Likewise, if X later becomes known not to be a member of SEQUENCE, a noticer attached to X restricts V to equal NIL.

* If V ever becomes known to equal T then a noticer attached to V restricts X to be a member of SEQUENCE. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X not to be a member of SEQUENCE.

The current implementation imposes two constraints on the parameter SEQUENCE. First, SEQUENCE must be bound when MEMBERV is called. Second, SEQUENCE must not contain any unbound variables when MEMBERV is called.

The value of parameter SEQUENCE must be a sequence, i.e. either a list or a vector.

Package

screamer

Source

screamer.lisp (file)

Function: minv X &rest XS

Constrains its arguments to be real. If called with a single argument, returns its value. If called with multiple arguments, behaves as if a combination of two argument calls:

(MINV X1 X2 ... Xn) == (MINV (MINV X1 X2) ... Xn)

If called with two arguments, and either is known to be less than or equal to the other, returns the value of that argument. Otherwise returns a real variable V, mutually constrained with the arguments:

* Minimum of the values of X1 and X2 is constrained to equal V. This includes constraining their bounds appropriately. If it becomes know that cannot be true. FAIL is called.

* If both arguments are integers, V is constrained to be an integer.

Package

screamer

Source

screamer.lisp (file)

Function: multiple-value-call-nondeterministic FUNCTION-FORM &rest VALUES-FORMS

Analogous to the CL:MULTIPLE-VALUE-CALL, except FUNCTION-FORM can evaluate to either a nondeterministic function, or an ordinary deterministic function.

You must use MULTIPLE-VALUE-CALL-NONDETERMINISTIC to multiple-value-call a nondeterministic function. An error is signalled if a nondeterministic function object is used with CL:MULTIPLE-VALUE-CALL.

You can use MULTIPLE-VALUE-CALL-NONDETERMINISTIC to call either a deterministic or nondeterministic function, though even if all of the VALUES-FORMS are deterministic and FUNCTION-FORM evaluates to a deterministic function object, the call expression will still be nondeterministic (with presumably a single value), since it is impossible to determine at compile time that a given call to MULTIPLE-VALUE-CALL-NONDETERMINISTIC will be passed only deterministic function objects for function.

While MULTIPLE-VALUE-CALL-NONDETERMINISTIC appears to be a function, it
is really a special-operator implemented by the code-walkers processing nondeterministic source contexts.

Package

screamer

Source

screamer.lisp (file)

Function: nondeterministic-function? X

Returns T if X is a nondeterministic function and NIL otherwise.

#’FOO returns a nondeterministic function object iff it is used in nondeterminisitc context and FOO is either a nondeterministic LAMBDA form, or the name of a nondeterministic function defined using SCREAMER::DEFUN.

Currently, if FOO is a nondeterministic function defined using
SCREAMER::DEFUN, #’FOO and (SYMBOL-FUNCTION ’FOO) in deterministic context
will return an ordinary deterministic Common Lisp function, which will signal an error at runtime.

Package

screamer

Source

screamer.lisp (file)

Function: notv X

Restricts X to be a boolean.

Returns T if this restricts X to NIL, and T if this restricts X to NIL.

Otherwise returns a new boolean variable V. V and X are mutually constrained via noticers, so that if either is later known to equal T, the other is restricted to equal NIL and vice versa.

Note that unlike CL:NOT NOTV does not accept arbitrary values as arguments: it fails if its argument is not T, NIL, or variable that can be restricted to a boolean.

Package

screamer

Source

screamer.lisp (file)

Function: numberpv X

Returns T if X is known to be numeric, NIL if X is known to be
non-numeric, and otherwise returns a new boolean variable V.

The values of X and V are mutually constrained via noticers so that V is equal to T if and only if X is known to be numeric and V is equal to NIL if and only if X is known to be non-numeric.

* If X later becomes known to be numeric, a noticer attached to X restricts V to equal T. Likewise, if X later becomes known to be non-numeric, a noticer attached to X restricts V to equal NIL.

* If V ever becomes known
to equal T then a noticer attached to V restricts X to be numeric. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X to be non-numeric.

Package

screamer

Source

screamer.lisp (file)

Function: orv &rest XS

Restricts each argument to be boolean.

Returns NIL if called with no arguments, or if all arguments are known to equal NIL after being restructed to be boolean, and returns T if any argument is known to equal T after this restriction.

Otherwise returns a boolean variable V. The values of arguments and V are mutually constrained:

* If any argument is later known to equal T, value of V becomes T.

* If all arguments are later known to equal NIL, value of V becomes NIL.

* If value of V is later known to equal NIL, all arguments become NIL.

* If value of V is later known to equal T, and all but one argument is known to be NIL, the remaining argument becomes T.

Note that unlike CL:OR, ORV is a function and always evaluates all its arguments. Secondly, any non-boolean argument causes it to fail.

Package

screamer

Source

screamer.lisp (file)

Function: purge FUNCTION-NAME

Removes any information about FUNCTION-NAME from Screamer’s who-calls database.

Package

screamer

Source

screamer.lisp (file)

Function: range-size X

Returns the range size of X. Range size is the size of the range values
of X may take.

If X is an integer or a bound variable whose value is an integer, it has the range size 0. Reals and bound variables whose values are reals have range size 0.0.

Unbound variables known to be reals with an upper and lower bound have a range size the difference of their upper and lower bounds.

Other types of objects and variables have range size NIL.

Package

screamer

Source

screamer.lisp (file)

Function: realpv X

Returns T if X is known to be real, NIL if X is known to be non-real,
and otherwise returns a new boolean variable V.

The values of X and V are mutually constrained via noticers so that V is equal to T if and only if X is known to be real and V is equal to NIL if and only if X is known to be non-real.

* If X later becomes known to be real, a noticer attached to X restricts V to equal T. Likewise, if X later becomes known to be non-real, a noticer attached to X restricts V to equal NIL.

* If V ever becomes known to equal T then a noticer attached to V restricts X to be real. Likewise, if V ever becomes known to equal NIL then a noticer attached to V restricts X to be non-real.

Package

screamer

Source

screamer.lisp (file)

Function: reorder COST-FUNCTION TERMINATE? ORDER FORCE-FUNCTION

Returns an ordering force function based on arguments.

The FORCE-FUNCTION is any (potentially nondeterministic) function
which can be applied to a variable as its single argument with the stipulation that a finite number of repeated applications will force
the variable to be bound. The FORCE-FUNCTION need not return any useful value.

The ordering force function which is returned is a nondeterministic function which takes a single argument X. This argument X can be a list of values where each value may be either a variable or a non-variable.

The ordering force function repeatedly selects a "best" variable using using COST-FUNCTION and ORDER. Eg. using #’DOMAIN-SIZE and #’< as the COST-FUNCTION and ORDER, then the variable with the smallest domain will be forced first.

Function TERMINATE? is then called with the determined cost of that variable, and unless it returns true, FORCE-FUNCTION is applied to that variable to force constrain it.

Process then iterates until all variables become bound or TERMINATE? returns true.

The ordering force function does not return any meaningful result.

Screamer currently provides two convenient force-functions, namely #’linear-force and #’divide-and-conquer-force though future implementations may provide additional ones. (The defined Screamer protocol does not provide sufficient hooks for the user to define her own force functions.)

Package

screamer

Source

screamer.lisp (file)

Function: solution ARGUMENTS ORDERING-FORCE-FUNCTION

ARGUMENTS is a list of values. Typically it is a list of
variables but it may also contain nonvariables.

The specified ORDERING-FORCE-FUNCTION is used to force each of the variables in list to be bound.

Returns a list of the values of the elements of list in the same order that they appear in list, irrespective of the forcing order imposed by the ORDERING-FORCE-FUNCTION.

The ORDERING-FORCE-FUNCTION can be any function which takes a list of values as its single argument that is guaranteed to force all variables in that list to be bound upon its return. The returned value of the ORDERING-FORCE-FUNCTION is ignored.

The user can construct her own ORDERING-FORCE-FUNCTION or use one of the following alternatives provided with Screamer:

(STATIC-ORDERING #’LINEAR-FORCE),
(STATIC-ORDERING #’DIVIDE-AND-CONQUER-FORCE),
(REORDER COST-FUN TERMINATE-TEST ORDER #’LINEAR-FORCE) and
(REORDER COST-FUN TERMINATE-TEST ORDER #’DIVIDE-AND-CONQUER-FORCE).

Future implementation of Screamer may provide additional forcing and ordering functions.

Package

screamer

Source

screamer.lisp (file)

Function: static-ordering FORCE-FUNCTION

Returns an ordering force function based on FORCE-FUNCTION.

The ordering force function which is returned is a nondeterministic function which takes a single argument X. This argument X can be a list of values where each value may be either a variable or a non-variable. The ordering force function applies the FORCE-FUNCTION in turn to each of the variables in X, in the order that they appear, repeatedly applying the FORCE-FUNCTION to a given variable until it becomes bound before proceeding to the next variable. The ordering force function does not return any meaningful result.

FORCE-FUNCTION is any (potentially nondeterministic) function which can be applied to a variable as its single argument with the stipulation that a finite number of repeated applications will force the variable to be bound. The FORCE-FUNCTION need not return any useful value.

Screamer currently provides two convenient force-functions, namely #’LINEAR-FORCE and #’DIVIDE-AND-CONQUER-FORCE though future implementations may provide additional ones. (The defined Screamer protocol does not provide sufficient hooks for the user to define her own force functions.)

Package

screamer

Source

screamer.lisp (file)

Function: template TEMPLATE

Copies an aggregate object, replacing any symbol beginning with a question mark with a newly created variable.

If the same symbol appears more than once in X, only one variable is created for that symbol, the same variable replacing any occurrences of that symbol. Thus (TEMPLATE ’(A B (?C D ?E) ?E)) has the same effect as:

(LET ((?C (MAKE-VARIABLE))
(?E (MAKE-VARIABLE)))
(LIST ’A ’B (LIST C ’D E) E)).

This is useful for creating patterns to be unified with other structures.

Package

screamer

Source

screamer.lisp (file)

Function: trail FUNCTION

When called in non-deterministic context, adds FUNCTION to the trail. Outside non-deterministic context does nothing.

Functions on the trail are called when unwinding from a nondeterministic selection (due to either a normal return, or calling FAIL.)

Package

screamer

Source

screamer.lisp (file)

Function: unwedge-screamer ()

Removes any information about all user defined functions from Screamer’s who-calls database.

Package

screamer

Source

screamer.lisp (file)

Function: unwind-trail ()

DEPRECATED.

Calls all functions installed using TRAIL, and removes them from the trail.

Using UNWIND-TRAIL is dangerous, as TRAIL is used by Screamer internally to eg. undo effects of local assignments – hence users should never call it. It is provided at the moment only for backwards compatibility with classic Screamer.

Package

screamer

Source

screamer.lisp (file)

Function: value-of X

Returns X if X is not a variable. If X is a variable then VALUE-OF dereferences X and returns the dereferenced value. If X is bound then the value returned will not be a variable. If X is unbound then the value returned will be a variable which may be X itself or another variable which is shared with X.

Package

screamer

Source

screamer.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *block-tags*

This must be globally NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *fail*
Package

screamer

Source

screamer.lisp (file)

Special Variable: *function-record-table*

The function record table.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *local?*

This must be globally NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *name*

The counter for anonymous names.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *nondeterministic-context?*

This must be globally NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *nondeterministic?*

This must be globally NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *ordered-lambda-list-keywords*

The allowed lambda list keywords in order.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *screamer?*

This must be NIL except when defining internal Screamer functions.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *tagbody-tags*

This must be globally NIL.

Package

screamer

Source

screamer.lisp (file)

Special Variable: *trail*

The trail.

Package

screamer

Source

screamer.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: choice-point FORM
Package

screamer

Source

screamer.lisp (file)

Macro: choice-point-external &rest FORMS
Package

screamer

Source

screamer.lisp (file)

Macro: choice-point-internal FORM
Package

screamer

Source

screamer.lisp (file)

Macro: defmacro-compile-time FUNCTION-NAME LAMBDA-LIST &body BODY
Package

screamer

Source

screamer.lisp (file)

Macro: defstruct-compile-time OPTIONS &body ITEMS
Package

screamer

Source

screamer.lisp (file)

Macro: defun FUNCTION-NAME LAMBDA-LIST &body BODY
Package

screamer

Source

screamer.lisp (file)

Macro: defun-compile-time FUNCTION-NAME LAMBDA-LIST &body BODY
Package

screamer

Source

screamer.lisp (file)

Macro: defvar-compile-time NAME &optional INITIAL-VALUE DOCUMENTATION
Package

screamer

Source

screamer.lisp (file)

Macro: multiple-value-bind VARIABLES FORM &body BODY
Package

screamer

Source

screamer.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: *-rule-down Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: *-rule-up Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: *v-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: *v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: +-rule-down Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: +-rule-up Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: +v-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: +v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: -v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: -v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: /-rule Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: /=-rule X Y
Package

screamer

Source

screamer.lisp (file)

Function: /=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: /=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: /v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: /v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: <-rule X Y
Package

screamer

Source

screamer.lisp (file)

Function: <=-rule X Y
Package

screamer

Source

screamer.lisp (file)

Function: <=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: <=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: <v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: <v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: =-rule X Y
Package

screamer

Source

screamer.lisp (file)

Function: =v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: =v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: >=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: >v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: a-boolean-nondeterministic CONTINUATION
Package

screamer

Source

screamer.lisp (file)

Function: a-member-of-nondeterministic CONTINUATION SEQUENCE
Package

screamer

Source

screamer.lisp (file)

Function: a-tuple VARIABLES VARIABLE VALUE
Package

screamer

Source

screamer.lisp (file)

Function: a-tuple-nondeterministic CONTINUATION-0 VARIABLES VARIABLE VALUE
Package

screamer

Source

screamer.lisp (file)

Function: an-integer-above-nondeterministic CONTINUATION LOW
Package

screamer

Source

screamer.lisp (file)

Function: an-integer-below-nondeterministic CONTINUATION HIGH
Package

screamer

Source

screamer.lisp (file)

Function: an-integer-between-nondeterministic CONTINUATION LOW HIGH
Package

screamer

Source

screamer.lisp (file)

Function: an-integer-nondeterministic CONTINUATION
Package

screamer

Source

screamer.lisp (file)

Function: andv-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: apply-nondeterministic-nondeterministic CONTINUATION FUNCTION ARGUMENT &rest ARGUMENTS
Package

screamer

Source

screamer.lisp (file)

Function: arguments-for-applyv X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-/=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-/=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-/=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-<v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!->=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!->=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!->v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!->v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-applyv F X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-booleanpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-clause XS PS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-constraint PREDICATE POLARITY? VARIABLES
Package

screamer

Source

screamer.lisp (file)

Function: assert!-constraint-ac PREDICATE POLARITY? VARIABLES
Package

screamer

Source

screamer.lisp (file)

Function: assert!-constraint-gfc PREDICATE POLARITY? VARIABLES
Package

screamer

Source

screamer.lisp (file)

Function: assert!-equalv X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-false X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-funcallv F &rest X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-integerpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-memberv X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-memberv-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-andv &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-andv-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-applyv F X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-booleanpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-equalv X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-funcallv F &rest X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-integerpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-memberv X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-memberv-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-numberpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-notv-realpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-numberpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-orv &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-orv-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: assert!-realpv X
Package

screamer

Source

screamer.lisp (file)

Function: assert!-true X
Package

screamer

Source

screamer.lisp (file)

Function: attach-noticer! NOTICER X
Package

screamer

Source

screamer.lisp (file)

Function: attach-noticer!-internal NOTICER X
Package

screamer

Source

screamer.lisp (file)

Function: cache-definition FUNCTION-NAME LAMBDA-LIST BODY CALLEES
Package

screamer

Source

screamer.lisp (file)

Function: callees FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: callers FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: check-function-name FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: check-lambda-list LAMBDA-LIST
Package

screamer

Source

screamer.lisp (file)

Function: check-lambda-list-internal LAMBDA-LIST &optional MODE
Package

screamer

Source

screamer.lisp (file)

Function: compute-callees BODY ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: contains-local-setf/setq? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: contains-variables? X
Package

screamer

Source

screamer.lisp (file)

Function: copy-function-record INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: copy-nondeterministic-function INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: copy-variable INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: corrupted? VARIABLE
Package

screamer

Source

screamer.lisp (file)

Function: count-trues-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: count-truesv-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert FORM CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-block NAME BODY CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-call FUNCTION-NAME ARGUMENTS CONTINUATION TYPES VALUE? ENVIRONMENT &optional DUMMY-ARGUMENTS
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-function-name FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-if ANTECEDENT CONSEQUENT ALTERNATE CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-let BINDINGS BODY DECLARATIONS CONTINUATION TYPES VALUE? ENVIRONMENT &optional NEW-BINDINGS
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-let* BINDINGS BODY DECLARATIONS CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-local-setf/setq ARGUMENTS CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-multiple-value-call NONDETERMINISTIC? FUNCTION FORMS CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-multiple-value-call-internal NONDETERMINISTIC? FUNCTION FORMS CONTINUATION TYPES VALUE? ENVIRONMENT &optional ARGUMENTS
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-multiple-value-prog1 FORM FORMS CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-progn BODY CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-return-from NAME RESULT ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-setq ARGUMENTS CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-convert-tagbody BODY CONTINUATION TYPES VALUE? ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: cps-non-convert-call FUNCTION-NAME ARGUMENTS CONTINUATION TYPES VALUE? ENVIRONMENT &optional DUMMY-ARGUMENTS
Package

screamer

Source

screamer.lisp (file)

Function: declare-deterministic FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: declare-nondeterministic FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: determine-whether-callers-are-deterministic FUNCTION-NAME FUNCTION-NAMES ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: determine-whether-deterministic FUNCTION-NAME ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: deterministic-lambda-list? LAMBDA-LIST ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: deterministic? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: divide-and-conquer-force-nondeterministic CONTINUATION-0 VARIABLE

Returns X if X is not a variable. If X is a bound variable then returns its value. Otherwise implements a single binary-branching step of a divide-and-conquer search algorithm. There are always two alternatives, the second of which is tried upon backtracking.

If it is known to have a finite domain D then this domain is split into two halves and the value of X is nondeterministically restricted to be a member one of the halves. If X becomes bound by this restriction then its value is returned. Otherwise, X itself is returned.

If X is not known to have a finite domain but is known to be real and to have both lower and upper bounds then nondeterministically either the lower or upper bound is restricted to the midpoint between the lower and upper bound. If X becomes bound by this restriction then its dereferenced value is returned. Otherwise, X itself is returned.

An error is signalled if X is not known to be restricted to a finite domain and either is not known to be real or is not known to have both a lower and upper bound.

When the set of potential values may be infinite, users of DIVIDE-AND-CONQUER-FORCE may need to take care to fail when the range size of the variable becomes too small, unless other constraints on it are sufficient to guarentee failure.

The method of splitting the domain into two halves is left unspecified to give future implementations leeway in incorporating heuristics in the process of determining a good search order. All that is specified is that if the domain size is even prior to splitting, the halves are of equal size, while if the domain size is odd, the halves differ in size by at most one.

Package

screamer

Source

screamer.lisp (file)

Function: eliminate-variables X
Package

screamer

Source

screamer.lisp (file)

Function: emacs-eval EXPRESSION
Package

screamer

Source

screamer.lisp (file)

Function: every-other LIST
Package

screamer

Source

screamer.lisp (file)

Function: expand-local-setf PAIRS ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: expand-local-setq PAIRS ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: find-best COST ORDER LIST
Package

screamer

Source

screamer.lisp (file)

Function: finite-domain? VARIABLE
Package

screamer

Source

screamer.lisp (file)

Function: form-callees FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: funcall-nondeterministic-nondeterministic CONTINUATION FUNCTION &rest ARGUMENTS
Package

screamer

Source

screamer.lisp (file)

Function: function-definition FUNCTION-NAME ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: function-record-body INSTANCE
Function: (setf function-record-body) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-callees INSTANCE
Function: (setf function-record-callees) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-deterministic? INSTANCE
Function: (setf function-record-deterministic?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-function-name INSTANCE
Function: (setf function-record-function-name) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-lambda-list INSTANCE
Function: (setf function-record-lambda-list) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-old-deterministic? INSTANCE
Function: (setf function-record-old-deterministic?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: function-record-p OBJECT
Package

screamer

Source

screamer.lisp (file)

Function: function-record-screamer? INSTANCE
Function: (setf function-record-screamer?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: get-function-record FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: indirect-callees FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: indirect-callees-internal FUNCTION-NAMES CALLEES
Package

screamer

Source

screamer.lisp (file)

Function: indirect-callers FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: indirect-callers-internal FUNCTION-NAMES CALLERS
Package

screamer

Source

screamer.lisp (file)

Function: infinity-* X Y
Package

screamer

Source

screamer.lisp (file)

Function: infinity-+ X Y
Package

screamer

Source

screamer.lisp (file)

Function: infinity-- X Y
Package

screamer

Source

screamer.lisp (file)

Function: infinity-max X Y
Package

screamer

Source

screamer.lisp (file)

Function: infinity-min X Y
Package

screamer

Source

screamer.lisp (file)

Function: integers-between LOW HIGH
Package

screamer

Source

screamer.lisp (file)

Function: is-magic-continuation? CONTINUATION
Package

screamer

Source

screamer.lisp (file)

Function: is-magic-declaration? FORM
Package

screamer

Source

screamer.lisp (file)

Function: known?-/=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-/=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-/=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-/=v2-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-/=v2-variable X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-<=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-<=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<=v2-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<=v2-variable X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-<v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-<v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<v2-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-<v2-variable X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-=v2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-=v2-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-=v2-variable X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?->=v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?->=v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?->v X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?->v-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-applyv F X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-booleanpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-constraint F POLARITY? X
Package

screamer

Source

screamer.lisp (file)

Function: known?-equalv X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-false X
Package

screamer

Source

screamer.lisp (file)

Function: known?-funcallv F &rest X
Package

screamer

Source

screamer.lisp (file)

Function: known?-integerpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-memberv X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-memberv-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-memberv-list X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-memberv-list-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-applyv F X &rest XS
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-booleanpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-equalv X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-funcallv F &rest X
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-integerpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-memberv X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-memberv-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-memberv-list X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-memberv-list-internal X Y
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-numberpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-notv-realpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-numberpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-realpv X
Package

screamer

Source

screamer.lisp (file)

Function: known?-true X
Package

screamer

Source

screamer.lisp (file)

Function: lambda-expression? FORM
Package

screamer

Source

screamer.lisp (file)

Function: linear-force-nondeterministic CONTINUATION-0 X

Returns X if it is not a variable. If X is a bound variable then returns its value.

If X is an unbound variable then it must be known to have a countable set of potential values. In this case X is nondeterministically restricted to be equal to one of the values in this countable set, thus forcing X to be bound. The dereferenced value of X is then returned.

An unbound variable is known to have a countable set of potential values either if it is known to have a finite domain or if it is known to be integer valued.

An error is signalled if X is not known to have a finite domain and is not known to be integer valued.

Upon backtracking X will be bound to each potential value in turn, failing when there remain no untried alternatives.

Since the set of potential values is required only to be countable, not finite, the set of untried alternatives may never be exhausted and backtracking need not terminate. This can happen, for instance, when X is known to be an integer but lacks either an upper of lower bound.

The order in which the nondeterministic alternatives are tried is left unspecified to give future implementations leeway in incorporating heuristics in the process of determining a good search order.

Package

screamer

Source

screamer.lisp (file)

Function: magic-continuation-argument CONTINUATION
Package

screamer

Source

screamer.lisp (file)

Function: make-function-record &key (FUNCTION-NAME FUNCTION-NAME) (LAMBDA-LIST LAMBDA-LIST) (BODY BODY) (CALLEES CALLEES) (DETERMINISTIC? DETERMINISTIC?) (OLD-DETERMINISTIC? OLD-DETERMINISTIC?) (SCREAMER? SCREAMER?)
Package

screamer

Source

screamer.lisp (file)

Function: make-nondeterministic-function &key (FUNCTION FUNCTION)
Package

screamer

Source

screamer.lisp (file)

Function: make-variable-internal &key (NAME NAME) (NOTICERS NOTICERS) (ENUMERATED-DOMAIN ENUMERATED-DOMAIN) (ENUMERATED-ANTIDOMAIN ENUMERATED-ANTIDOMAIN) (VALUE VALUE) (POSSIBLY-INTEGER? POSSIBLY-INTEGER?) (POSSIBLY-NONINTEGER-REAL? POSSIBLY-NONINTEGER-REAL?) (POSSIBLY-NONREAL-NUMBER? POSSIBLY-NONREAL-NUMBER?) (POSSIBLY-BOOLEAN? POSSIBLY-BOOLEAN?) (POSSIBLY-NONBOOLEAN-NONNUMBER? POSSIBLY-NONBOOLEAN-NONNUMBER?) (LOWER-BOUND LOWER-BOUND) (UPPER-BOUND UPPER-BOUND)
Package

screamer

Source

screamer.lisp (file)

Function: max-rule-down Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: max-rule-up Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: maxv-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: maxv2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: min-rule-down Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: min-rule-up Z X Y
Package

screamer

Source

screamer.lisp (file)

Function: minv-internal X XS
Package

screamer

Source

screamer.lisp (file)

Function: minv2 X Y
Package

screamer

Source

screamer.lisp (file)

Function: modified-function-definitions FUNCTION-NAME ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: needs-substitution? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: nondeterministic-function-function INSTANCE
Function: (setf nondeterministic-function-function) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: nondeterministic-function?-internal OBJECT
Package

screamer

Source

screamer.lisp (file)

Function: occurs-in? X VALUE
Package

screamer

Source

screamer.lisp (file)

Function: orv-internal XS
Package

screamer

Source

screamer.lisp (file)

Function: peal-off-documentation-string-and-declarations BODY &optional DOCUMENTATION-STRING?
Package

screamer

Source

screamer.lisp (file)

Function: perform-substitutions FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: possibly-beta-reduce-funcall CONTINUATION TYPES FORM VALUE?
Package

screamer

Source

screamer.lisp (file)

Function: print-nondeterministic-function NONDETERMINISTIC-FUNCTION STREAM PRINT-LEVEL
Package

screamer

Source

screamer.lisp (file)

Function: print-variable X STREAM PRINT-LEVEL
Package

screamer

Source

screamer.lisp (file)

Function: process-subforms FUNCTION FORM FORM-TYPE ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: propagate-ac PREDICATE POLARITY? VARIABLES
Package

screamer

Source

screamer.lisp (file)

Function: propagate-gfc PREDICATE POLARITY? VARIABLES UNASSIGNED-VARIABLE
Package

screamer

Source

screamer.lisp (file)

Function: prune-enumerated-domain X &optional ENUMERATED-DOMAIN
Package

screamer

Source

screamer.lisp (file)

Function: quotify THING
Package

screamer

Source

screamer.lisp (file)

Function: reorder-internal VARIABLES COST-FUNCTION TERMINATE? ORDER FORCE-FUNCTION
Package

screamer

Source

screamer.lisp (file)

Function: reorder-internal-nondeterministic CONTINUATION-0 VARIABLES COST-FUNCTION TERMINATE? ORDER FORCE-FUNCTION
Package

screamer

Source

screamer.lisp (file)

Function: restrict-boolean! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-bounds! X LOWER-BOUND UPPER-BOUND
Package

screamer

Source

screamer.lisp (file)

Function: restrict-enumerated-antidomain! X ENUMERATED-ANTIDOMAIN
Package

screamer

Source

screamer.lisp (file)

Function: restrict-enumerated-domain! X ENUMERATED-DOMAIN
Package

screamer

Source

screamer.lisp (file)

Function: restrict-false! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-integer! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-lower-bound! X LOWER-BOUND
Package

screamer

Source

screamer.lisp (file)

Function: restrict-nonboolean! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-noninteger! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-nonnumber! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-nonreal! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-number! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-real! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-true! X
Package

screamer

Source

screamer.lisp (file)

Function: restrict-upper-bound! X UPPER-BOUND
Package

screamer

Source

screamer.lisp (file)

Function: restrict-value! X VALUE
Package

screamer

Source

screamer.lisp (file)

Function: run-noticers X
Package

screamer

Source

screamer.lisp (file)

Function: screamer-error HEADER &rest ARGS
Package

screamer

Source

screamer.lisp (file)

Function: self-evaluating? THING
Package

screamer

Source

screamer.lisp (file)

Function: set-enumerated-domain! X ENUMERATED-DOMAIN
Package

screamer

Source

screamer.lisp (file)

Function: share! X Y
Package

screamer

Source

screamer.lisp (file)

Function: solution-nondeterministic CONTINUATION-0 ARGUMENTS ORDERING-FORCE-FUNCTION

ARGUMENTS is a list of values. Typically it is a list of
variables but it may also contain nonvariables.

The specified ORDERING-FORCE-FUNCTION is used to force each of the variables in list to be bound.

Returns a list of the values of the elements of list in the same order that they appear in list, irrespective of the forcing order imposed by the ORDERING-FORCE-FUNCTION.

The ORDERING-FORCE-FUNCTION can be any function which takes a list of values as its single argument that is guaranteed to force all variables in that list to be bound upon its return. The returned value of the ORDERING-FORCE-FUNCTION is ignored.

The user can construct her own ORDERING-FORCE-FUNCTION or use one of the following alternatives provided with Screamer:

(STATIC-ORDERING #’LINEAR-FORCE),
(STATIC-ORDERING #’DIVIDE-AND-CONQUER-FORCE),
(REORDER COST-FUN TERMINATE-TEST ORDER #’LINEAR-FORCE) and
(REORDER COST-FUN TERMINATE-TEST ORDER #’DIVIDE-AND-CONQUER-FORCE).

Future implementation of Screamer may provide additional forcing and ordering functions.

Package

screamer

Source

screamer.lisp (file)

Function: static-ordering-internal VARIABLES FORCE-FUNCTION
Package

screamer

Source

screamer.lisp (file)

Function: static-ordering-internal-nondeterministic CONTINUATION-0 VARIABLES FORCE-FUNCTION
Package

screamer

Source

screamer.lisp (file)

Function: template-internal TEMPLATE VARIABLES
Package

screamer

Source

screamer.lisp (file)

Function: transform-assert! FORM POLARITY?
Package

screamer

Source

screamer.lisp (file)

Function: transform-decide FORM POLARITY?
Package

screamer

Source

screamer.lisp (file)

Function: transform-known? FORM POLARITY?
Package

screamer

Source

screamer.lisp (file)

Function: unwind-trail-to TRAIL-POINTER
Package

screamer

Source

screamer.lisp (file)

Function: valid-function-name? FUNCTION-NAME
Package

screamer

Source

screamer.lisp (file)

Function: variable-boolean? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-enumerated-antidomain INSTANCE
Function: (setf variable-enumerated-antidomain) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-enumerated-domain INSTANCE
Function: (setf variable-enumerated-domain) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-false? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-integer? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-lower-bound INSTANCE
Function: (setf variable-lower-bound) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-name INSTANCE
Function: (setf variable-name) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-nonboolean? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-noninteger? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-nonnumber? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-nonreal? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-noticers INSTANCE
Function: (setf variable-noticers) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-number? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-possibly-boolean? INSTANCE
Function: (setf variable-possibly-boolean?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-possibly-integer? INSTANCE
Function: (setf variable-possibly-integer?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-possibly-nonboolean-nonnumber? INSTANCE
Function: (setf variable-possibly-nonboolean-nonnumber?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-possibly-noninteger-real? INSTANCE
Function: (setf variable-possibly-noninteger-real?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-possibly-nonreal-number? INSTANCE
Function: (setf variable-possibly-nonreal-number?) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-real? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-true? X
Package

screamer

Source

screamer.lisp (file)

Function: variable-upper-bound INSTANCE
Function: (setf variable-upper-bound) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable-value INSTANCE
Function: (setf variable-value) VALUE INSTANCE
Package

screamer

Source

screamer.lisp (file)

Function: variable? OBJECT
Package

screamer

Source

screamer.lisp (file)

Function: variables-in X
Package

screamer

Source

screamer.lisp (file)

Function: variablize X
Package

screamer

Source

screamer.lisp (file)

Function: void-continuation CONTINUATION
Package

screamer

Source

screamer.lisp (file)

Function: walk MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-block MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-catch MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-eval-when MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-flet/labels MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT FORM-TYPE
Package

screamer

Source

screamer.lisp (file)

Function: walk-for-effects MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-full MAP-FUNCTION FORM
Package

screamer

Source

screamer.lisp (file)

Function: walk-function MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-function-call MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-go MAP-FUNCTION FORM
Package

screamer

Source

screamer.lisp (file)

Function: walk-if MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-lambda-list MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? LAMBDA-LIST ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-lambda-list-reducing MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? LAMBDA-LIST ENVIRONMENT &optional MODE
Package

screamer

Source

screamer.lisp (file)

Function: walk-let/let* MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT FORM-TYPE
Package

screamer

Source

screamer.lisp (file)

Function: walk-macro-call MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-multiple-value-call MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-multiple-value-call-nondeterministic MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-multiple-value-prog1 MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-progn MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-progv MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-quote MAP-FUNCTION FORM
Package

screamer

Source

screamer.lisp (file)

Function: walk-return-from MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-setf MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-setq MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-tagbody MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-the MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-throw MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: walk-unwind-protect MAP-FUNCTION REDUCE-FUNCTION SCREAMER? PARTIAL? NESTED? FORM ENVIRONMENT
Package

screamer

Source

screamer.lisp (file)

Function: y-or-n-p &optional FORMAT-STRING &rest FORMAT-ARGS
Package

screamer

Source

screamer.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Structures

Structure: function-record ()
Package

screamer

Source

screamer.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: function-name
Readers

function-record-function-name (function)

Writers

(setf function-record-function-name) (function)

Slot: lambda-list
Readers

function-record-lambda-list (function)

Writers

(setf function-record-lambda-list) (function)

Slot: body
Readers

function-record-body (function)

Writers

(setf function-record-body) (function)

Slot: callees
Readers

function-record-callees (function)

Writers

(setf function-record-callees) (function)

Slot: deterministic?
Initform

t

Readers

function-record-deterministic? (function)

Writers

(setf function-record-deterministic?) (function)

Slot: old-deterministic?
Readers

function-record-old-deterministic? (function)

Writers

(setf function-record-old-deterministic?) (function)

Slot: screamer?
Initform

screamer::*screamer?*

Readers

function-record-screamer? (function)

Writers

(setf function-record-screamer?) (function)

Structure: nondeterministic-function ()
Package

screamer

Source

screamer.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: function
Readers

nondeterministic-function-function (function)

Writers

(setf nondeterministic-function-function) (function)

Structure: variable ()
Package

screamer

Source

screamer.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: name
Readers

variable-name (function)

Writers

(setf variable-name) (function)

Slot: noticers
Readers

variable-noticers (function)

Writers

(setf variable-noticers) (function)

Slot: enumerated-domain
Initform

t

Readers

variable-enumerated-domain (function)

Writers

(setf variable-enumerated-domain) (function)

Slot: enumerated-antidomain
Readers

variable-enumerated-antidomain (function)

Writers

(setf variable-enumerated-antidomain) (function)

Slot: value
Readers

variable-value (function)

Writers

(setf variable-value) (function)

Slot: possibly-integer?
Initform

t

Readers

variable-possibly-integer? (function)

Writers

(setf variable-possibly-integer?) (function)

Slot: possibly-noninteger-real?
Initform

t

Readers

variable-possibly-noninteger-real? (function)

Writers

(setf variable-possibly-noninteger-real?) (function)

Slot: possibly-nonreal-number?
Initform

t

Readers

variable-possibly-nonreal-number? (function)

Writers

(setf variable-possibly-nonreal-number?) (function)

Slot: possibly-boolean?
Initform

t

Readers

variable-possibly-boolean? (function)

Writers

(setf variable-possibly-boolean?) (function)

Slot: possibly-nonboolean-nonnumber?
Initform

t

Readers

variable-possibly-nonboolean-nonnumber? (function)

Writers

(setf variable-possibly-nonboolean-nonnumber?) (function)

Slot: lower-bound
Readers

variable-lower-bound (function)

Writers

(setf variable-lower-bound) (function)

Slot: upper-bound
Readers

variable-upper-bound (function)

Writers

(setf variable-upper-bound) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   S  
Index Entry  Section

F
File, Lisp, screamer.asd: The screamer<dot>asd file
File, Lisp, screamer/package.lisp: The screamer/package<dot>lisp file
File, Lisp, screamer/screamer.lisp: The screamer/screamer<dot>lisp file

L
Lisp File, screamer.asd: The screamer<dot>asd file
Lisp File, screamer/package.lisp: The screamer/package<dot>lisp file
Lisp File, screamer/screamer.lisp: The screamer/screamer<dot>lisp file

S
screamer.asd: The screamer<dot>asd file
screamer/package.lisp: The screamer/package<dot>lisp file
screamer/screamer.lisp: The screamer/screamer<dot>lisp file

Jump to:   F   L   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (   *   +   -   /   <   =   >  
A   B   C   D   E   F   G   I   K   L   M   N   O   P   Q   R   S   T   U   V   W   Y  
Index Entry  Section

(
(setf function-record-body): Internal functions
(setf function-record-callees): Internal functions
(setf function-record-deterministic?): Internal functions
(setf function-record-function-name): Internal functions
(setf function-record-lambda-list): Internal functions
(setf function-record-old-deterministic?): Internal functions
(setf function-record-screamer?): Internal functions
(setf nondeterministic-function-function): Internal functions
(setf variable-enumerated-antidomain): Internal functions
(setf variable-enumerated-domain): Internal functions
(setf variable-lower-bound): Internal functions
(setf variable-name): Internal functions
(setf variable-noticers): Internal functions
(setf variable-possibly-boolean?): Internal functions
(setf variable-possibly-integer?): Internal functions
(setf variable-possibly-nonboolean-nonnumber?): Internal functions
(setf variable-possibly-noninteger-real?): Internal functions
(setf variable-possibly-nonreal-number?): Internal functions
(setf variable-upper-bound): Internal functions
(setf variable-value): Internal functions

*
*-rule-down: Internal functions
*-rule-up: Internal functions
*v: Exported functions
*v-internal: Internal functions
*v2: Internal functions

+
+-rule-down: Internal functions
+-rule-up: Internal functions
+v: Exported functions
+v-internal: Internal functions
+v2: Internal functions

-
-v: Exported functions
-v-internal: Internal functions
-v2: Internal functions

/
/-rule: Internal functions
/=-rule: Internal functions
/=v: Exported functions
/=v-internal: Internal functions
/=v2: Internal functions
/v: Exported functions
/v-internal: Internal functions
/v2: Internal functions

<
<-rule: Internal functions
<=-rule: Internal functions
<=v: Exported functions
<=v-internal: Internal functions
<=v2: Internal functions
<v: Exported functions
<v-internal: Internal functions
<v2: Internal functions

=
=-rule: Internal functions
=v: Exported functions
=v-internal: Internal functions
=v2: Internal functions

>
>=v: Exported functions
>=v-internal: Internal functions
>v: Exported functions
>v-internal: Internal functions

A
a-boolean: Exported functions
a-boolean-nondeterministic: Internal functions
a-booleanv: Exported functions
a-member-of: Exported functions
a-member-of-nondeterministic: Internal functions
a-member-ofv: Exported functions
a-numberv: Exported functions
a-real-abovev: Exported functions
a-real-belowv: Exported functions
a-real-betweenv: Exported functions
a-realv: Exported functions
a-tuple: Internal functions
a-tuple-nondeterministic: Internal functions
all-values: Exported macros
an-integer: Exported functions
an-integer-above: Exported functions
an-integer-above-nondeterministic: Internal functions
an-integer-abovev: Exported functions
an-integer-below: Exported functions
an-integer-below-nondeterministic: Internal functions
an-integer-belowv: Exported functions
an-integer-between: Exported functions
an-integer-between-nondeterministic: Internal functions
an-integer-betweenv: Exported functions
an-integer-nondeterministic: Internal functions
an-integerv: Exported functions
andv: Exported functions
andv-internal: Internal functions
apply-nondeterministic: Exported functions
apply-nondeterministic-nondeterministic: Internal functions
apply-substitution: Exported functions
applyv: Exported functions
arguments-for-applyv: Internal functions
assert!: Exported macros
assert!-/=v: Internal functions
assert!-/=v-internal: Internal functions
assert!-/=v2: Internal functions
assert!-<=v: Internal functions
assert!-<=v-internal: Internal functions
assert!-<=v2: Internal functions
assert!-<v: Internal functions
assert!-<v-internal: Internal functions
assert!-<v2: Internal functions
assert!-=v: Internal functions
assert!-=v-internal: Internal functions
assert!-=v2: Internal functions
assert!->=v: Internal functions
assert!->=v-internal: Internal functions
assert!->v: Internal functions
assert!->v-internal: Internal functions
assert!-applyv: Internal functions
assert!-booleanpv: Internal functions
assert!-clause: Internal functions
assert!-constraint: Internal functions
assert!-constraint-ac: Internal functions
assert!-constraint-gfc: Internal functions
assert!-equalv: Internal functions
assert!-false: Internal functions
assert!-funcallv: Internal functions
assert!-integerpv: Internal functions
assert!-memberv: Internal functions
assert!-memberv-internal: Internal functions
assert!-notv-andv: Internal functions
assert!-notv-andv-internal: Internal functions
assert!-notv-applyv: Internal functions
assert!-notv-booleanpv: Internal functions
assert!-notv-equalv: Internal functions
assert!-notv-funcallv: Internal functions
assert!-notv-integerpv: Internal functions
assert!-notv-memberv: Internal functions
assert!-notv-memberv-internal: Internal functions
assert!-notv-numberpv: Internal functions
assert!-notv-realpv: Internal functions
assert!-numberpv: Internal functions
assert!-orv: Internal functions
assert!-orv-internal: Internal functions
assert!-realpv: Internal functions
assert!-true: Internal functions
attach-noticer!: Internal functions
attach-noticer!-internal: Internal functions

B
best-value: Exported macros
booleanp: Exported functions
booleanpv: Exported functions
bound?: Exported functions

C
cache-definition: Internal functions
callees: Internal functions
callers: Internal functions
check-function-name: Internal functions
check-lambda-list: Internal functions
check-lambda-list-internal: Internal functions
choice-point: Internal macros
choice-point-external: Internal macros
choice-point-internal: Internal macros
compute-callees: Internal functions
contains-local-setf/setq?: Internal functions
contains-variables?: Internal functions
copy-function-record: Internal functions
copy-nondeterministic-function: Internal functions
copy-variable: Internal functions
corrupted?: Internal functions
count-failures: Exported macros
count-trues: Exported functions
count-trues-internal: Internal functions
count-truesv: Exported functions
count-truesv-internal: Internal functions
cps-convert: Internal functions
cps-convert-block: Internal functions
cps-convert-call: Internal functions
cps-convert-function-name: Internal functions
cps-convert-if: Internal functions
cps-convert-let: Internal functions
cps-convert-let*: Internal functions
cps-convert-local-setf/setq: Internal functions
cps-convert-multiple-value-call: Internal functions
cps-convert-multiple-value-call-internal: Internal functions
cps-convert-multiple-value-prog1: Internal functions
cps-convert-progn: Internal functions
cps-convert-return-from: Internal functions
cps-convert-setq: Internal functions
cps-convert-tagbody: Internal functions
cps-non-convert-call: Internal functions

D
decide: Exported macros
declare-deterministic: Internal functions
declare-nondeterministic: Internal functions
define-screamer-package: Exported macros
defmacro-compile-time: Internal macros
defstruct-compile-time: Internal macros
defun: Internal macros
defun-compile-time: Internal macros
defvar-compile-time: Internal macros
determine-whether-callers-are-deterministic: Internal functions
determine-whether-deterministic: Internal functions
deterministic-lambda-list?: Internal functions
deterministic?: Internal functions
divide-and-conquer-force: Exported functions
divide-and-conquer-force-nondeterministic: Internal functions
domain-size: Exported functions

E
either: Exported macros
eliminate-variables: Internal functions
emacs-eval: Internal functions
equalv: Exported functions
every-other: Internal functions
expand-local-setf: Internal functions
expand-local-setq: Internal functions

F
fail: Exported functions
find-best: Internal functions
finite-domain?: Internal functions
for-effects: Exported macros
form-callees: Internal functions
funcall-nondeterministic: Exported functions
funcall-nondeterministic-nondeterministic: Internal functions
funcallv: Exported functions
Function, (setf function-record-body): Internal functions
Function, (setf function-record-callees): Internal functions
Function, (setf function-record-deterministic?): Internal functions
Function, (setf function-record-function-name): Internal functions
Function, (setf function-record-lambda-list): Internal functions
Function, (setf function-record-old-deterministic?): Internal functions
Function, (setf function-record-screamer?): Internal functions
Function, (setf nondeterministic-function-function): Internal functions
Function, (setf variable-enumerated-antidomain): Internal functions
Function, (setf variable-enumerated-domain): Internal functions
Function, (setf variable-lower-bound): Internal functions
Function, (setf variable-name): Internal functions
Function, (setf variable-noticers): Internal functions
Function, (setf variable-possibly-boolean?): Internal functions
Function, (setf variable-possibly-integer?): Internal functions
Function, (setf variable-possibly-nonboolean-nonnumber?): Internal functions
Function, (setf variable-possibly-noninteger-real?): Internal functions
Function, (setf variable-possibly-nonreal-number?): Internal functions
Function, (setf variable-upper-bound): Internal functions
Function, (setf variable-value): Internal functions
Function, *-rule-down: Internal functions
Function, *-rule-up: Internal functions
Function, *v: Exported functions
Function, *v-internal: Internal functions
Function, *v2: Internal functions
Function, +-rule-down: Internal functions
Function, +-rule-up: Internal functions
Function, +v: Exported functions
Function, +v-internal: Internal functions
Function, +v2: Internal functions
Function, -v: Exported functions
Function, -v-internal: Internal functions
Function, -v2: Internal functions
Function, /-rule: Internal functions
Function, /=-rule: Internal functions
Function, /=v: Exported functions
Function, /=v-internal: Internal functions
Function, /=v2: Internal functions
Function, /v: Exported functions
Function, /v-internal: Internal functions
Function, /v2: Internal functions
Function, <-rule: Internal functions
Function, <=-rule: Internal functions
Function, <=v: Exported functions
Function, <=v-internal: Internal functions
Function, <=v2: Internal functions
Function, <v: Exported functions
Function, <v-internal: Internal functions
Function, <v2: Internal functions
Function, =-rule: Internal functions
Function, =v: Exported functions
Function, =v-internal: Internal functions
Function, =v2: Internal functions
Function, >=v: Exported functions
Function, >=v-internal: Internal functions
Function, >v: Exported functions
Function, >v-internal: Internal functions
Function, a-boolean: Exported functions
Function, a-boolean-nondeterministic: Internal functions
Function, a-booleanv: Exported functions
Function, a-member-of: Exported functions
Function, a-member-of-nondeterministic: Internal functions
Function, a-member-ofv: Exported functions
Function, a-numberv: Exported functions
Function, a-real-abovev: Exported functions
Function, a-real-belowv: Exported functions
Function, a-real-betweenv: Exported functions
Function, a-realv: Exported functions
Function, a-tuple: Internal functions
Function, a-tuple-nondeterministic: Internal functions
Function, an-integer: Exported functions
Function, an-integer-above: Exported functions
Function, an-integer-above-nondeterministic: Internal functions
Function, an-integer-abovev: Exported functions
Function, an-integer-below: Exported functions
Function, an-integer-below-nondeterministic: Internal functions
Function, an-integer-belowv: Exported functions
Function, an-integer-between: Exported functions
Function, an-integer-between-nondeterministic: Internal functions
Function, an-integer-betweenv: Exported functions
Function, an-integer-nondeterministic: Internal functions
Function, an-integerv: Exported functions
Function, andv: Exported functions
Function, andv-internal: Internal functions
Function, apply-nondeterministic: Exported functions
Function, apply-nondeterministic-nondeterministic: Internal functions
Function, apply-substitution: Exported functions
Function, applyv: Exported functions
Function, arguments-for-applyv: Internal functions
Function, assert!-/=v: Internal functions
Function, assert!-/=v-internal: Internal functions
Function, assert!-/=v2: Internal functions
Function, assert!-<=v: Internal functions
Function, assert!-<=v-internal: Internal functions
Function, assert!-<=v2: Internal functions
Function, assert!-<v: Internal functions
Function, assert!-<v-internal: Internal functions
Function, assert!-<v2: Internal functions
Function, assert!-=v: Internal functions
Function, assert!-=v-internal: Internal functions
Function, assert!-=v2: Internal functions
Function, assert!->=v: Internal functions
Function, assert!->=v-internal: Internal functions
Function, assert!->v: Internal functions
Function, assert!->v-internal: Internal functions
Function, assert!-applyv: Internal functions
Function, assert!-booleanpv: Internal functions
Function, assert!-clause: Internal functions
Function, assert!-constraint: Internal functions
Function, assert!-constraint-ac: Internal functions
Function, assert!-constraint-gfc: Internal functions
Function, assert!-equalv: Internal functions
Function, assert!-false: Internal functions
Function, assert!-funcallv: Internal functions
Function, assert!-integerpv: Internal functions
Function, assert!-memberv: Internal functions
Function, assert!-memberv-internal: Internal functions
Function, assert!-notv-andv: Internal functions
Function, assert!-notv-andv-internal: Internal functions
Function, assert!-notv-applyv: Internal functions
Function, assert!-notv-booleanpv: Internal functions
Function, assert!-notv-equalv: Internal functions
Function, assert!-notv-funcallv: Internal functions
Function, assert!-notv-integerpv: Internal functions
Function, assert!-notv-memberv: Internal functions
Function, assert!-notv-memberv-internal: Internal functions
Function, assert!-notv-numberpv: Internal functions
Function, assert!-notv-realpv: Internal functions
Function, assert!-numberpv: Internal functions
Function, assert!-orv: Internal functions
Function, assert!-orv-internal: Internal functions
Function, assert!-realpv: Internal functions
Function, assert!-true: Internal functions
Function, attach-noticer!: Internal functions
Function, attach-noticer!-internal: Internal functions
Function, booleanp: Exported functions
Function, booleanpv: Exported functions
Function, bound?: Exported functions
Function, cache-definition: Internal functions
Function, callees: Internal functions
Function, callers: Internal functions
Function, check-function-name: Internal functions
Function, check-lambda-list: Internal functions
Function, check-lambda-list-internal: Internal functions
Function, compute-callees: Internal functions
Function, contains-local-setf/setq?: Internal functions
Function, contains-variables?: Internal functions
Function, copy-function-record: Internal functions
Function, copy-nondeterministic-function: Internal functions
Function, copy-variable: Internal functions
Function, corrupted?: Internal functions
Function, count-trues: Exported functions
Function, count-trues-internal: Internal functions
Function, count-truesv: Exported functions
Function, count-truesv-internal: Internal functions
Function, cps-convert: Internal functions
Function, cps-convert-block: Internal functions
Function, cps-convert-call: Internal functions
Function, cps-convert-function-name: Internal functions
Function, cps-convert-if: Internal functions
Function, cps-convert-let: Internal functions
Function, cps-convert-let*: Internal functions
Function, cps-convert-local-setf/setq: Internal functions
Function, cps-convert-multiple-value-call: Internal functions
Function, cps-convert-multiple-value-call-internal: Internal functions
Function, cps-convert-multiple-value-prog1: Internal functions
Function, cps-convert-progn: Internal functions
Function, cps-convert-return-from: Internal functions
Function, cps-convert-setq: Internal functions
Function, cps-convert-tagbody: Internal functions
Function, cps-non-convert-call: Internal functions
Function, declare-deterministic: Internal functions
Function, declare-nondeterministic: Internal functions
Function, determine-whether-callers-are-deterministic: Internal functions
Function, determine-whether-deterministic: Internal functions
Function, deterministic-lambda-list?: Internal functions
Function, deterministic?: Internal functions
Function, divide-and-conquer-force: Exported functions
Function, divide-and-conquer-force-nondeterministic: Internal functions
Function, domain-size: Exported functions
Function, eliminate-variables: Internal functions
Function, emacs-eval: Internal functions
Function, equalv: Exported functions
Function, every-other: Internal functions
Function, expand-local-setf: Internal functions
Function, expand-local-setq: Internal functions
Function, fail: Exported functions
Function, find-best: Internal functions
Function, finite-domain?: Internal functions
Function, form-callees: Internal functions
Function, funcall-nondeterministic: Exported functions
Function, funcall-nondeterministic-nondeterministic: Internal functions
Function, funcallv: Exported functions
Function, function-definition: Internal functions
Function, function-record-body: Internal functions
Function, function-record-callees: Internal functions
Function, function-record-deterministic?: Internal functions
Function, function-record-function-name: Internal functions
Function, function-record-lambda-list: Internal functions
Function, function-record-old-deterministic?: Internal functions
Function, function-record-p: Internal functions
Function, function-record-screamer?: Internal functions
Function, get-function-record: Internal functions
Function, ground?: Exported functions
Function, indirect-callees: Internal functions
Function, indirect-callees-internal: Internal functions
Function, indirect-callers: Internal functions
Function, indirect-callers-internal: Internal functions
Function, infinity-*: Internal functions
Function, infinity-+: Internal functions
Function, infinity--: Internal functions
Function, infinity-max: Internal functions
Function, infinity-min: Internal functions
Function, integerpv: Exported functions
Function, integers-between: Internal functions
Function, is-magic-continuation?: Internal functions
Function, is-magic-declaration?: Internal functions
Function, known?-/=v: Internal functions
Function, known?-/=v-internal: Internal functions
Function, known?-/=v2: Internal functions
Function, known?-/=v2-internal: Internal functions
Function, known?-/=v2-variable: Internal functions
Function, known?-<=v: Internal functions
Function, known?-<=v-internal: Internal functions
Function, known?-<=v2: Internal functions
Function, known?-<=v2-internal: Internal functions
Function, known?-<=v2-variable: Internal functions
Function, known?-<v: Internal functions
Function, known?-<v-internal: Internal functions
Function, known?-<v2: Internal functions
Function, known?-<v2-internal: Internal functions
Function, known?-<v2-variable: Internal functions
Function, known?-=v: Internal functions
Function, known?-=v-internal: Internal functions
Function, known?-=v2: Internal functions
Function, known?-=v2-internal: Internal functions
Function, known?-=v2-variable: Internal functions
Function, known?->=v: Internal functions
Function, known?->=v-internal: Internal functions
Function, known?->v: Internal functions
Function, known?->v-internal: Internal functions
Function, known?-applyv: Internal functions
Function, known?-booleanpv: Internal functions
Function, known?-constraint: Internal functions
Function, known?-equalv: Internal functions
Function, known?-false: Internal functions
Function, known?-funcallv: Internal functions
Function, known?-integerpv: Internal functions
Function, known?-memberv: Internal functions
Function, known?-memberv-internal: Internal functions
Function, known?-memberv-list: Internal functions
Function, known?-memberv-list-internal: Internal functions
Function, known?-notv-applyv: Internal functions
Function, known?-notv-booleanpv: Internal functions
Function, known?-notv-equalv: Internal functions
Function, known?-notv-funcallv: Internal functions
Function, known?-notv-integerpv: Internal functions
Function, known?-notv-memberv: Internal functions
Function, known?-notv-memberv-internal: Internal functions
Function, known?-notv-memberv-list: Internal functions
Function, known?-notv-memberv-list-internal: Internal functions
Function, known?-notv-numberpv: Internal functions
Function, known?-notv-realpv: Internal functions
Function, known?-numberpv: Internal functions
Function, known?-realpv: Internal functions
Function, known?-true: Internal functions
Function, lambda-expression?: Internal functions
Function, linear-force: Exported functions
Function, linear-force-nondeterministic: Internal functions
Function, magic-continuation-argument: Internal functions
Function, make-function-record: Internal functions
Function, make-nondeterministic-function: Internal functions
Function, make-variable: Exported functions
Function, make-variable-internal: Internal functions
Function, max-rule-down: Internal functions
Function, max-rule-up: Internal functions
Function, maxv: Exported functions
Function, maxv-internal: Internal functions
Function, maxv2: Internal functions
Function, memberv: Exported functions
Function, min-rule-down: Internal functions
Function, min-rule-up: Internal functions
Function, minv: Exported functions
Function, minv-internal: Internal functions
Function, minv2: Internal functions
Function, modified-function-definitions: Internal functions
Function, multiple-value-call-nondeterministic: Exported functions
Function, needs-substitution?: Internal functions
Function, nondeterministic-function-function: Internal functions
Function, nondeterministic-function?: Exported functions
Function, nondeterministic-function?-internal: Internal functions
Function, notv: Exported functions
Function, numberpv: Exported functions
Function, occurs-in?: Internal functions
Function, orv: Exported functions
Function, orv-internal: Internal functions
Function, peal-off-documentation-string-and-declarations: Internal functions
Function, perform-substitutions: Internal functions
Function, possibly-beta-reduce-funcall: Internal functions
Function, print-nondeterministic-function: Internal functions
Function, print-variable: Internal functions
Function, process-subforms: Internal functions
Function, propagate-ac: Internal functions
Function, propagate-gfc: Internal functions
Function, prune-enumerated-domain: Internal functions
Function, purge: Exported functions
Function, quotify: Internal functions
Function, range-size: Exported functions
Function, realpv: Exported functions
Function, reorder: Exported functions
Function, reorder-internal: Internal functions
Function, reorder-internal-nondeterministic: Internal functions
Function, restrict-boolean!: Internal functions
Function, restrict-bounds!: Internal functions
Function, restrict-enumerated-antidomain!: Internal functions
Function, restrict-enumerated-domain!: Internal functions
Function, restrict-false!: Internal functions
Function, restrict-integer!: Internal functions
Function, restrict-lower-bound!: Internal functions
Function, restrict-nonboolean!: Internal functions
Function, restrict-noninteger!: Internal functions
Function, restrict-nonnumber!: Internal functions
Function, restrict-nonreal!: Internal functions
Function, restrict-number!: Internal functions
Function, restrict-real!: Internal functions
Function, restrict-true!: Internal functions
Function, restrict-upper-bound!: Internal functions
Function, restrict-value!: Internal functions
Function, run-noticers: Internal functions
Function, screamer-error: Internal functions
Function, self-evaluating?: Internal functions
Function, set-enumerated-domain!: Internal functions
Function, share!: Internal functions
Function, solution: Exported functions
Function, solution-nondeterministic: Internal functions
Function, static-ordering: Exported functions
Function, static-ordering-internal: Internal functions
Function, static-ordering-internal-nondeterministic: Internal functions
Function, template: Exported functions
Function, template-internal: Internal functions
Function, trail: Exported functions
Function, transform-assert!: Internal functions
Function, transform-decide: Internal functions
Function, transform-known?: Internal functions
Function, unwedge-screamer: Exported functions
Function, unwind-trail: Exported functions
Function, unwind-trail-to: Internal functions
Function, valid-function-name?: Internal functions
Function, value-of: Exported functions
Function, variable-boolean?: Internal functions
Function, variable-enumerated-antidomain: Internal functions
Function, variable-enumerated-domain: Internal functions
Function, variable-false?: Internal functions
Function, variable-integer?: Internal functions
Function, variable-lower-bound: Internal functions
Function, variable-name: Internal functions
Function, variable-nonboolean?: Internal functions
Function, variable-noninteger?: Internal functions
Function, variable-nonnumber?: Internal functions
Function, variable-nonreal?: Internal functions
Function, variable-noticers: Internal functions
Function, variable-number?: Internal functions
Function, variable-possibly-boolean?: Internal functions
Function, variable-possibly-integer?: Internal functions
Function, variable-possibly-nonboolean-nonnumber?: Internal functions
Function, variable-possibly-noninteger-real?: Internal functions
Function, variable-possibly-nonreal-number?: Internal functions
Function, variable-real?: Internal functions
Function, variable-true?: Internal functions
Function, variable-upper-bound: Internal functions
Function, variable-value: Internal functions
Function, variable?: Internal functions
Function, variables-in: Internal functions
Function, variablize: Internal functions
Function, void-continuation: Internal functions
Function, walk: Internal functions
Function, walk-block: Internal functions
Function, walk-catch: Internal functions
Function, walk-eval-when: Internal functions
Function, walk-flet/labels: Internal functions
Function, walk-for-effects: Internal functions
Function, walk-full: Internal functions
Function, walk-function: Internal functions
Function, walk-function-call: Internal functions
Function, walk-go: Internal functions
Function, walk-if: Internal functions
Function, walk-lambda-list: Internal functions
Function, walk-lambda-list-reducing: Internal functions
Function, walk-let/let*: Internal functions
Function, walk-macro-call: Internal functions
Function, walk-multiple-value-call: Internal functions
Function, walk-multiple-value-call-nondeterministic: Internal functions
Function, walk-multiple-value-prog1: Internal functions
Function, walk-progn: Internal functions
Function, walk-progv: Internal functions
Function, walk-quote: Internal functions
Function, walk-return-from: Internal functions
Function, walk-setf: Internal functions
Function, walk-setq: Internal functions
Function, walk-tagbody: Internal functions
Function, walk-the: Internal functions
Function, walk-throw: Internal functions
Function, walk-unwind-protect: Internal functions
Function, y-or-n-p: Internal functions
function-definition: Internal functions
function-record-body: Internal functions
function-record-callees: Internal functions
function-record-deterministic?: Internal functions
function-record-function-name: Internal functions
function-record-lambda-list: Internal functions
function-record-old-deterministic?: Internal functions
function-record-p: Internal functions
function-record-screamer?: Internal functions

G
get-function-record: Internal functions
global: Exported macros
ground?: Exported functions

I
indirect-callees: Internal functions
indirect-callees-internal: Internal functions
indirect-callers: Internal functions
indirect-callers-internal: Internal functions
infinity-*: Internal functions
infinity-+: Internal functions
infinity--: Internal functions
infinity-max: Internal functions
infinity-min: Internal functions
integerpv: Exported functions
integers-between: Internal functions
is-magic-continuation?: Internal functions
is-magic-declaration?: Internal functions
ith-value: Exported macros

K
known?: Exported macros
known?-/=v: Internal functions
known?-/=v-internal: Internal functions
known?-/=v2: Internal functions
known?-/=v2-internal: Internal functions
known?-/=v2-variable: Internal functions
known?-<=v: Internal functions
known?-<=v-internal: Internal functions
known?-<=v2: Internal functions
known?-<=v2-internal: Internal functions
known?-<=v2-variable: Internal functions
known?-<v: Internal functions
known?-<v-internal: Internal functions
known?-<v2: Internal functions
known?-<v2-internal: Internal functions
known?-<v2-variable: Internal functions
known?-=v: Internal functions
known?-=v-internal: Internal functions
known?-=v2: Internal functions
known?-=v2-internal: Internal functions
known?-=v2-variable: Internal functions
known?->=v: Internal functions
known?->=v-internal: Internal functions
known?->v: Internal functions
known?->v-internal: Internal functions
known?-applyv: Internal functions
known?-booleanpv: Internal functions
known?-constraint: Internal functions
known?-equalv: Internal functions
known?-false: Internal functions
known?-funcallv: Internal functions
known?-integerpv: Internal functions
known?-memberv: Internal functions
known?-memberv-internal: Internal functions
known?-memberv-list: Internal functions
known?-memberv-list-internal: Internal functions
known?-notv-applyv: Internal functions
known?-notv-booleanpv: Internal functions
known?-notv-equalv: Internal functions
known?-notv-funcallv: Internal functions
known?-notv-integerpv: Internal functions
known?-notv-memberv: Internal functions
known?-notv-memberv-internal: Internal functions
known?-notv-memberv-list: Internal functions
known?-notv-memberv-list-internal: Internal functions
known?-notv-numberpv: Internal functions
known?-notv-realpv: Internal functions
known?-numberpv: Internal functions
known?-realpv: Internal functions
known?-true: Internal functions

L
lambda-expression?: Internal functions
linear-force: Exported functions
linear-force-nondeterministic: Internal functions
local: Exported macros
local-output: Exported macros

M
Macro, all-values: Exported macros
Macro, assert!: Exported macros
Macro, best-value: Exported macros
Macro, choice-point: Internal macros
Macro, choice-point-external: Internal macros
Macro, choice-point-internal: Internal macros
Macro, count-failures: Exported macros
Macro, decide: Exported macros
Macro, define-screamer-package: Exported macros
Macro, defmacro-compile-time: Internal macros
Macro, defstruct-compile-time: Internal macros
Macro, defun: Internal macros
Macro, defun-compile-time: Internal macros
Macro, defvar-compile-time: Internal macros
Macro, either: Exported macros
Macro, for-effects: Exported macros
Macro, global: Exported macros
Macro, ith-value: Exported macros
Macro, known?: Exported macros
Macro, local: Exported macros
Macro, local-output: Exported macros
Macro, multiple-value-bind: Internal macros
Macro, necessarily?: Exported macros
Macro, one-value: Exported macros
Macro, possibly?: Exported macros
Macro, print-values: Exported macros
Macro, when-failing: Exported macros
magic-continuation-argument: Internal functions
make-function-record: Internal functions
make-nondeterministic-function: Internal functions
make-variable: Exported functions
make-variable-internal: Internal functions
max-rule-down: Internal functions
max-rule-up: Internal functions
maxv: Exported functions
maxv-internal: Internal functions
maxv2: Internal functions
memberv: Exported functions
min-rule-down: Internal functions
min-rule-up: Internal functions
minv: Exported functions
minv-internal: Internal functions
minv2: Internal functions
modified-function-definitions: Internal functions
multiple-value-bind: Internal macros
multiple-value-call-nondeterministic: Exported functions

N
necessarily?: Exported macros
needs-substitution?: Internal functions
nondeterministic-function-function: Internal functions
nondeterministic-function?: Exported functions
nondeterministic-function?-internal: Internal functions
notv: Exported functions
numberpv: Exported functions

O
occurs-in?: Internal functions
one-value: Exported macros
orv: Exported functions
orv-internal: Internal functions

P
peal-off-documentation-string-and-declarations: Internal functions
perform-substitutions: Internal functions
possibly-beta-reduce-funcall: Internal functions
possibly?: Exported macros
print-nondeterministic-function: Internal functions
print-values: Exported macros
print-variable: Internal functions
process-subforms: Internal functions
propagate-ac: Internal functions
propagate-gfc: Internal functions
prune-enumerated-domain: Internal functions
purge: Exported functions

Q
quotify: Internal functions

R
range-size: Exported functions
realpv: Exported functions
reorder: Exported functions
reorder-internal: Internal functions
reorder-internal-nondeterministic: Internal functions
restrict-boolean!: Internal functions
restrict-bounds!: Internal functions
restrict-enumerated-antidomain!: Internal functions
restrict-enumerated-domain!: Internal functions
restrict-false!: Internal functions
restrict-integer!: Internal functions
restrict-lower-bound!: Internal functions
restrict-nonboolean!: Internal functions
restrict-noninteger!: Internal functions
restrict-nonnumber!: Internal functions
restrict-nonreal!: Internal functions
restrict-number!: Internal functions
restrict-real!: Internal functions
restrict-true!: Internal functions
restrict-upper-bound!: Internal functions
restrict-value!: Internal functions
run-noticers: Internal functions

S
screamer-error: Internal functions
self-evaluating?: Internal functions
set-enumerated-domain!: Internal functions
share!: Internal functions
solution: Exported functions
solution-nondeterministic: Internal functions
static-ordering: Exported functions
static-ordering-internal: Internal functions
static-ordering-internal-nondeterministic: Internal functions

T
template: Exported functions
template-internal: Internal functions
trail: Exported functions
transform-assert!: Internal functions
transform-decide: Internal functions
transform-known?: Internal functions

U
unwedge-screamer: Exported functions
unwind-trail: Exported functions
unwind-trail-to: Internal functions

V
valid-function-name?: Internal functions
value-of: Exported functions
variable-boolean?: Internal functions
variable-enumerated-antidomain: Internal functions
variable-enumerated-domain: Internal functions
variable-false?: Internal functions
variable-integer?: Internal functions
variable-lower-bound: Internal functions
variable-name: Internal functions
variable-nonboolean?: Internal functions
variable-noninteger?: Internal functions
variable-nonnumber?: Internal functions
variable-nonreal?: Internal functions
variable-noticers: Internal functions
variable-number?: Internal functions
variable-possibly-boolean?: Internal functions
variable-possibly-integer?: Internal functions
variable-possibly-nonboolean-nonnumber?: Internal functions
variable-possibly-noninteger-real?: Internal functions
variable-possibly-nonreal-number?: Internal functions
variable-real?: Internal functions
variable-true?: Internal functions
variable-upper-bound: Internal functions
variable-value: Internal functions
variable?: Internal functions
variables-in: Internal functions
variablize: Internal functions
void-continuation: Internal functions

W
walk: Internal functions
walk-block: Internal functions
walk-catch: Internal functions
walk-eval-when: Internal functions
walk-flet/labels: Internal functions
walk-for-effects: Internal functions
walk-full: Internal functions
walk-function: Internal functions
walk-function-call: Internal functions
walk-go: Internal functions
walk-if: Internal functions
walk-lambda-list: Internal functions
walk-lambda-list-reducing: Internal functions
walk-let/let*: Internal functions
walk-macro-call: Internal functions
walk-multiple-value-call: Internal functions
walk-multiple-value-call-nondeterministic: Internal functions
walk-multiple-value-prog1: Internal functions
walk-progn: Internal functions
walk-progv: Internal functions
walk-quote: Internal functions
walk-return-from: Internal functions
walk-setf: Internal functions
walk-setq: Internal functions
walk-tagbody: Internal functions
walk-the: Internal functions
walk-throw: Internal functions
walk-unwind-protect: Internal functions
when-failing: Exported macros

Y
y-or-n-p: Internal functions

Jump to:   (   *   +   -   /   <   =   >  
A   B   C   D   E   F   G   I   K   L   M   N   O   P   Q   R   S   T   U   V   W   Y  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
B   C   D   E   F   L   N   O   P   S   U   V  
Index Entry  Section

*
*block-tags*: Internal special variables
*dynamic-extent?*: Exported special variables
*fail*: Internal special variables
*function-record-table*: Internal special variables
*iscream?*: Exported special variables
*local?*: Internal special variables
*maximum-discretization-range*: Exported special variables
*minimum-shrink-ratio*: Exported special variables
*name*: Internal special variables
*nondeterministic-context?*: Internal special variables
*nondeterministic?*: Internal special variables
*ordered-lambda-list-keywords*: Internal special variables
*screamer-version*: Exported special variables
*screamer?*: Internal special variables
*strategy*: Exported special variables
*tagbody-tags*: Internal special variables
*trail*: Internal special variables

B
body: Internal structures

C
callees: Internal structures

D
deterministic?: Internal structures

E
enumerated-antidomain: Internal structures
enumerated-domain: Internal structures

F
function: Internal structures
function-name: Internal structures

L
lambda-list: Internal structures
lower-bound: Internal structures

N
name: Internal structures
noticers: Internal structures

O
old-deterministic?: Internal structures

P
possibly-boolean?: Internal structures
possibly-integer?: Internal structures
possibly-nonboolean-nonnumber?: Internal structures
possibly-noninteger-real?: Internal structures
possibly-nonreal-number?: Internal structures

S
screamer?: Internal structures
Slot, body: Internal structures
Slot, callees: Internal structures
Slot, deterministic?: Internal structures
Slot, enumerated-antidomain: Internal structures
Slot, enumerated-domain: Internal structures
Slot, function: Internal structures
Slot, function-name: Internal structures
Slot, lambda-list: Internal structures
Slot, lower-bound: Internal structures
Slot, name: Internal structures
Slot, noticers: Internal structures
Slot, old-deterministic?: Internal structures
Slot, possibly-boolean?: Internal structures
Slot, possibly-integer?: Internal structures
Slot, possibly-nonboolean-nonnumber?: Internal structures
Slot, possibly-noninteger-real?: Internal structures
Slot, possibly-nonreal-number?: Internal structures
Slot, screamer?: Internal structures
Slot, upper-bound: Internal structures
Slot, value: Internal structures
Special Variable, *block-tags*: Internal special variables
Special Variable, *dynamic-extent?*: Exported special variables
Special Variable, *fail*: Internal special variables
Special Variable, *function-record-table*: Internal special variables
Special Variable, *iscream?*: Exported special variables
Special Variable, *local?*: Internal special variables
Special Variable, *maximum-discretization-range*: Exported special variables
Special Variable, *minimum-shrink-ratio*: Exported special variables
Special Variable, *name*: Internal special variables
Special Variable, *nondeterministic-context?*: Internal special variables
Special Variable, *nondeterministic?*: Internal special variables
Special Variable, *ordered-lambda-list-keywords*: Internal special variables
Special Variable, *screamer-version*: Exported special variables
Special Variable, *screamer?*: Internal special variables
Special Variable, *strategy*: Exported special variables
Special Variable, *tagbody-tags*: Internal special variables
Special Variable, *trail*: Internal special variables

U
upper-bound: Internal structures

V
value: Internal structures

Jump to:   *  
B   C   D   E   F   L   N   O   P   S   U   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   F   N   P   S   V  
Index Entry  Section

F
function-record: Internal structures

N
nondeterministic-function: Internal structures

P
Package, screamer: The screamer package
Package, screamer-user: The screamer-user package

S
screamer: The screamer system
screamer: The screamer package
screamer-user: The screamer-user package
Structure, function-record: Internal structures
Structure, nondeterministic-function: Internal structures
Structure, variable: Internal structures
System, screamer: The screamer system

V
variable: Internal structures

Jump to:   F   N   P   S   V