The cl-grnm Reference Manual

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

The cl-grnm Reference Manual

This is the cl-grnm Reference Manual, version 0.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 03:45:00 2022 GMT+0.

Table of Contents


1 Introduction

cl-grnm

Common-Lisp implementations of the grid-restrained and traditional Nelder-Mead algorithms

Authorship

This package was originally written by Mario S. Mommer (2006), and this fork is maintained by Rigetti Computing.

Introduction

These common lisp sources contain two variants of the Nelder-Mead algorithm. The original algorithm [1] and a provably convergent, reliable variant by A. Bürmen et al [4], called the "Grid Restrained Nelder Mead Algorithm" (GRNMA).

It should be mentioned that other, provably convergent variant exist [2,3], which aren't included here. The only reasons are lack of time, and the fact that the implemented variant does not require a simple descent condition, putting it closer to the original.

Other than that, and based on the article [4], the performance of these methods seems to be about equal in terms of number of function evaluations. As a side effect of the additional reliability, both tend to be a lot more efficient than the original algorithm even when it does not fail. In particular when the number of dimensions increases. As a test, one might try the GRNM,

(grnm-optimize #'standard-quadratic (make-array 30 :initial-element 1.0d0) :verbose t)

and compare with the original Nelder-Mead,

(nm-optimize #'standard-quadratic (make-array 30 :initial-element 1.0d0) :verbose t)

and observe the difference in number of function evaluations (the last value returned).

(This exercise also serves to illustrate the overall deficiencies of direct search algorithms when applied to higher dimensional problems.)

This software is provided under the MIT license; see LICENSE.txt for details.

Usage

This implementation of the grid restrained Nelder-Mead algorithm expects at least two parameters: the objective function, and an initial guess. It returns four values:

The objective function should accept a double-float array as its argument.

The initial guess will usually be an array of double-float numbers (but instead an object of the class NM-SIMPLEX may also be provided; see below). For example,

(grnm-optimize #'rosenbrock #(40.0d0 40.0d0))

finds the minimum of the Rosenbrock function, and

(grnm-optimize #'standard-quadratic (make-array 30 :initial-element 1.0d0))

finds the minimum of the standard quadratic function in 30 dimensions.

A few keyword arguments can customize the behavior. These are

:verbose (default: NIL)

Pass T here if you want to see some progress report. The amount of output can be controlled by setting verbose-level to 1 or 2. The difference is that with 1 (the default) only the best value of the simplex is shown, while with 2 the whole simplex is printed on each iteration.

:converged-p (default: burmen-et-al-convergence-test)

The burmen-et-al-convergence-test is, as the name suggests, the convergence test used in the article by Bürmen et al. It accepts a few parameters: tol-x, tol-f and rel; please see the article for further details.

Another convergence criterion that can be given is (pp-volume-test <tol>), which returns true once the parallelogram(!) spanned by the vertices of the simplex has a volume lower than <tol> to the power of N, where N is the dimension of the problem. This is a rather expensive test, as it involves computing a QR decomposition of an N by N matrix on each call.

If you are not in the mood of taking prisoners, you might as well pass (constantly NIL) as the convergence criterion. This has as a consequence that the iteration continues until the simplex collapses, which in floating-point arithmetic happens in finite time. The grid restrained Nelder-Mead algorithm should have converged by then.

:max-function-calls (default: NIL)

Maximum number of objective function evaluations. After that many function evaluations, this implementation of the algorithm will declare convergence to have occurred.

The actual number of function calls might be slightly larger (at most by N), as the relevant condition is only checked in certain situations.

Utilities/Misc

NM-optimize

Apart from the grid-restrained Nelder Mead algorithm, the traditional variant is also provided. The corresponding function is named NM-optimize, and its usage is the same as for GRNM-optimize.

The only difference is that :max-function-calls has a default value of 100000. Otherwise the algorithm might well iterate forever.

initial-simplex <initial guess> :displace <displacement>

Constructs an initial simplex with the double-float array <initial guess> as on of its corners.

The displacement can be a an array of double floats or a number. In the first case, the additional vertices of the simplex are build by adding to each component of the <initial guess> the corresponding component in <displacement>. If it is a number, then the additional vertices are build by adding <displacement> to each component of the <initial guess>.

Tips & Tricks

References

[1] J.A. Nelder and R. Mead, "A simplex method for function minimization," The Computer Journal, vol. 7, pp. 308-313, 1965.

[2] P. Tseng, "Fortified-descent simplicial search method: A general approach," SIAM Journal on Optimization, vol. 10, pp. 269-288, 1999.

[3] C.J. Price, I.D. Coope, and D. Byatt, "A convergent variant of the Nelder-Mead algorithm," Journal of Optimization Theory and Applications, vol. 113, pp. 5-19, 2002.

[4] A. Bürmen, J. Puhan and T. Tuma, "Grid Restrained Nelder-Mead Algorithm", Computational Optimization and Applications, vol. 34, no. 3, pp. 359 - 375, 2006


2 Systems

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


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

2.1 cl-grnm

Grid Restrained Nelder-Mead, a multivariate rootfinder.

Author

Rigetti Computing and Mario S. Sommer

License

MIT (See LICENSE.txt)

Version

0.1.0

Source

cl-grnm.asd.

Child Components

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   [Contents][Index]

3.1.1 cl-grnm/cl-grnm.asd

Source

cl-grnm.asd.

Parent Component

cl-grnm (system).

ASDF Systems

cl-grnm.

Packages

cl-grnm-asd.


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

3.1.2 cl-grnm/defpackage.lisp

Source

cl-grnm.asd.

Parent Component

cl-grnm (system).

Packages

cl-grnm.


3.1.3 cl-grnm/la.lisp

Dependency

defpackage.lisp (file).

Source

cl-grnm.asd.

Parent Component

cl-grnm (system).

Internals

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

3.1.4 cl-grnm/neldermead.lisp

Dependency

la.lisp (file).

Source

cl-grnm.asd.

Parent Component

cl-grnm (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


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

4.1 cl-grnm-asd

Source

cl-grnm.asd.

Use List
  • asdf/interface.
  • common-lisp.

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

4.2 cl-grnm

Source

defpackage.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


5.1.1 Ordinary functions

Function: burmen-et-al-convergence-test (&key tol-x tol-f rel)
Package

cl-grnm.

Source

neldermead.lisp.

Function: grnm-optimize (objective-function initial-guess &key max-function-calls convergence-p verbose)
Package

cl-grnm.

Source

neldermead.lisp.

Function: initial-simplex (x0 &key displace)
Package

cl-grnm.

Source

neldermead.lisp.

Function: nm-optimize (objective-function initial-guess &key max-function-calls convergence-p verbose)
Package

cl-grnm.

Source

neldermead.lisp.

Function: pp-volume-test (cside)
Package

cl-grnm.

Source

neldermead.lisp.

Function: rosenbrock (v)
Package

cl-grnm.

Source

neldermead.lisp.

Function: standard-quadratic (v)
Package

cl-grnm.

Source

neldermead.lisp.


5.1.2 Standalone methods

Method: print-object ((s nm-simplex) stream)
Source

neldermead.lisp.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *biglambda*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *breakdown*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *psi*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *smalllambda*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *tau-a*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *tau-r*
Package

cl-grnm.

Source

neldermead.lisp.

Special Variable: *verbose-level*
Package

cl-grnm.

Source

neldermead.lisp.


5.2.2 Macros

Macro: with-matrix-dimensions (varforms &body body)
Package

cl-grnm.

Source

la.lisp.


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

5.2.3 Ordinary functions

Function: deep-shrink (f s g gamma_s convergence-p verbose)
Package

cl-grnm.

Source

neldermead.lisp.

Function: default-initial-simplex (x0)
Package

cl-grnm.

Source

neldermead.lisp.

Function: ip (v w &optional start)
Package

cl-grnm.

Source

la.lisp.

Function: make-matrix (m n)
Package

cl-grnm.

Source

la.lisp.

Function: make-vector (n &key initial-element)
Package

cl-grnm.

Source

la.lisp.

Function: nm-iteration (simplex f &key verbose gamma_reflect gamma_expand gamma_outer_contraction gamma_inner_contraction gamma_shrink)
Package

cl-grnm.

Source

neldermead.lisp.

Function: nm-iteration-burmen-et-al (simplex f grid &key verbose gamma_reflect gamma_expand gamma_outer_contraction gamma_inner_contraction)
Package

cl-grnm.

Source

neldermead.lisp.

Function: norm (v &optional start)
Package

cl-grnm.

Source

la.lisp.

Function: qr-factorization (mat &key with-q)
Package

cl-grnm.

Source

la.lisp.

Function: qrthing-closure (s n)
Package

cl-grnm.

Source

neldermead.lisp.

Function: regrid (g x1 dmin fkt)
Package

cl-grnm.

Source

neldermead.lisp.

Function: simplex-qr-thing (sidev)
Package

cl-grnm.

Source

neldermead.lisp.

Function: v*c (vector constant)
Package

cl-grnm.

Source

la.lisp.

Function: v+w*c (v w c)
Package

cl-grnm.

Source

la.lisp.


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

5.2.4 Generic functions

Generic Reader: best-before-reshape (object)
Package

cl-grnm.

Methods
Reader Method: best-before-reshape ((cached-simplex-data cached-simplex-data))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

best-before-reshape.

Generic Writer: (setf best-before-reshape) (object)
Package

cl-grnm.

Methods
Writer Method: (setf best-before-reshape) ((cached-simplex-data cached-simplex-data))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

best-before-reshape.

Generic Function: cached-slot (s slot computer)
Package

cl-grnm.

Methods
Method: cached-slot ((s nm-simplex) slot computer)
Source

neldermead.lisp.

Generic Reader: data (object)
Package

cl-grnm.

Methods
Reader Method: data ((nm-simplex nm-simplex))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

data.

Generic Writer: (setf data) (object)
Package

cl-grnm.

Methods
Writer Method: (setf data) ((nm-simplex nm-simplex))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

data.

Generic Reader: delta (object)
Package

cl-grnm.

Methods
Reader Method: delta ((grid grid))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

delta.

Generic Writer: (setf delta) (object)
Package

cl-grnm.

Methods
Writer Method: (setf delta) ((grid grid))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

delta.

Generic Function: dimension (s)
Package

cl-grnm.

Methods
Method: dimension ((s nm-simplex))
Source

neldermead.lisp.

Generic Reader: dmin (object)
Package

cl-grnm.

Methods
Reader Method: dmin ((cached-simplex-data cached-simplex-data))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

dmin.

Generic Writer: (setf dmin) (object)
Package

cl-grnm.

Methods
Writer Method: (setf dmin) ((cached-simplex-data cached-simplex-data))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

dmin.

Generic Reader: dv (object)
Package

cl-grnm.

Methods
Reader Method: dv ((cached-simplex-data cached-simplex-data))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

dv.

Generic Writer: (setf dv) (object)
Package

cl-grnm.

Methods
Writer Method: (setf dv) ((cached-simplex-data cached-simplex-data))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

dv.

Generic Function: fk (s k)
Package

cl-grnm.

Methods
Method: fk ((s nm-simplex) k)
Source

neldermead.lisp.

Generic Function: (setf fk) (s k)
Package

cl-grnm.

Methods
Method: (setf fk) ((s nm-simplex) k)
Source

neldermead.lisp.

Generic Reader: fx (object)
Package

cl-grnm.

Methods
Reader Method: fx ((nm-simplex nm-simplex))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

fx.

Generic Writer: (setf fx) (object)
Package

cl-grnm.

Methods
Writer Method: (setf fx) ((nm-simplex nm-simplex))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

fx.

Generic Reader: grid-z (object)
Package

cl-grnm.

Methods
Reader Method: grid-z ((grid grid))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

z.

Generic Writer: (setf grid-z) (object)
Package

cl-grnm.

Methods
Writer Method: (setf grid-z) ((grid grid))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

z.

Generic Function: improve (s x fx)
Package

cl-grnm.

Methods
Method: improve ((s nm-simplex) x fx)
Source

neldermead.lisp.

Generic Function: maybe-fill-simplex (s f)
Package

cl-grnm.

Methods
Method: maybe-fill-simplex ((s nm-simplex) f)
Source

neldermead.lisp.

Generic Function: maybe-reshape (s g ff &key force)
Package

cl-grnm.

Methods
Method: maybe-reshape ((s nm-simplex) (g grid) ff &key force)
Source

neldermead.lisp.

Generic Reader: pmap (object)
Package

cl-grnm.

Methods
Reader Method: pmap ((nm-simplex nm-simplex))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

pmap.

Generic Writer: (setf pmap) (object)
Package

cl-grnm.

Methods
Writer Method: (setf pmap) ((nm-simplex nm-simplex))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

pmap.

Generic Function: pseudopivot (s)
Package

cl-grnm.

Methods
Method: pseudopivot ((s nm-simplex))
Source

neldermead.lisp.

Generic Function: q-factor (s)
Package

cl-grnm.

Methods
Method: q-factor ((s nm-simplex))
Source

neldermead.lisp.

Generic Function: r-factor (s)
Package

cl-grnm.

Methods
Method: r-factor ((s nm-simplex))
Source

neldermead.lisp.

Generic Function: restrict (grid point)
Package

cl-grnm.

Methods
Method: restrict ((grid grid) point)
Source

neldermead.lisp.

Generic Function: side-vectors (s)
Package

cl-grnm.

Methods
Method: side-vectors ((s nm-simplex))
Source

neldermead.lisp.

Generic Function: sort-simplex (s)
Package

cl-grnm.

Methods
Method: sort-simplex ((s nm-simplex))
Source

neldermead.lisp.

Generic Reader: x (object)
Package

cl-grnm.

Methods
Reader Method: x ((nm-simplex nm-simplex))

automatically generated reader method

Source

neldermead.lisp.

Target Slot

x.

Generic Writer: (setf x) (object)
Package

cl-grnm.

Methods
Writer Method: (setf x) ((nm-simplex nm-simplex))

automatically generated writer method

Source

neldermead.lisp.

Target Slot

x.

Generic Function: xk (s k)
Package

cl-grnm.

Methods
Method: xk ((s nm-simplex) k)
Source

neldermead.lisp.

Generic Function: (setf xk) (s k)
Package

cl-grnm.

Methods
Method: (setf xk) ((s nm-simplex) k)
Source

neldermead.lisp.


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

5.2.5 Classes

Class: cached-simplex-data
Package

cl-grnm.

Source

neldermead.lisp.

Direct methods
Direct slots
Slot: pseudopivot
Slot: q-factor
Slot: side-vectors
Slot: r-factor
Slot: dv
Initargs

:dv

Readers

dv.

Writers

(setf dv).

Slot: dmin
Initargs

:dmin

Readers

dmin.

Writers

(setf dmin).

Slot: best-before-reshape
Initargs

:best-before-reshape

Readers

best-before-reshape.

Writers

(setf best-before-reshape).

Class: grid
Package

cl-grnm.

Source

neldermead.lisp.

Direct methods
Direct slots
Slot: z
Initargs

:z

Readers

grid-z.

Writers

(setf grid-z).

Slot: delta
Initargs

:delta

Readers

delta.

Writers

(setf delta).

Class: nm-simplex
Package

cl-grnm.

Source

neldermead.lisp.

Direct methods
Direct slots
Slot: x
Initargs

:x

Readers

x.

Writers

(setf x).

Slot: fx
Initargs

:fx

Readers

fx.

Writers

(setf fx).

Slot: pmap
Initargs

:pmap

Readers

pmap.

Writers

(setf pmap).

Slot: data
Readers

data.

Writers

(setf data).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
B   C   D   F   G   I   M   N   P   Q   R   S   V   W   X  
Index Entry  Section

(
(setf best-before-reshape): Private generic functions
(setf best-before-reshape): Private generic functions
(setf data): Private generic functions
(setf data): Private generic functions
(setf delta): Private generic functions
(setf delta): Private generic functions
(setf dmin): Private generic functions
(setf dmin): Private generic functions
(setf dv): Private generic functions
(setf dv): Private generic functions
(setf fk): Private generic functions
(setf fk): Private generic functions
(setf fx): Private generic functions
(setf fx): Private generic functions
(setf grid-z): Private generic functions
(setf grid-z): Private generic functions
(setf pmap): Private generic functions
(setf pmap): Private generic functions
(setf x): Private generic functions
(setf x): Private generic functions
(setf xk): Private generic functions
(setf xk): Private generic functions

B
best-before-reshape: Private generic functions
best-before-reshape: Private generic functions
burmen-et-al-convergence-test: Public ordinary functions

C
cached-slot: Private generic functions
cached-slot: Private generic functions

D
data: Private generic functions
data: Private generic functions
deep-shrink: Private ordinary functions
default-initial-simplex: Private ordinary functions
delta: Private generic functions
delta: Private generic functions
dimension: Private generic functions
dimension: Private generic functions
dmin: Private generic functions
dmin: Private generic functions
dv: Private generic functions
dv: Private generic functions

F
fk: Private generic functions
fk: Private generic functions
Function, burmen-et-al-convergence-test: Public ordinary functions
Function, deep-shrink: Private ordinary functions
Function, default-initial-simplex: Private ordinary functions
Function, grnm-optimize: Public ordinary functions
Function, initial-simplex: Public ordinary functions
Function, ip: Private ordinary functions
Function, make-matrix: Private ordinary functions
Function, make-vector: Private ordinary functions
Function, nm-iteration: Private ordinary functions
Function, nm-iteration-burmen-et-al: Private ordinary functions
Function, nm-optimize: Public ordinary functions
Function, norm: Private ordinary functions
Function, pp-volume-test: Public ordinary functions
Function, qr-factorization: Private ordinary functions
Function, qrthing-closure: Private ordinary functions
Function, regrid: Private ordinary functions
Function, rosenbrock: Public ordinary functions
Function, simplex-qr-thing: Private ordinary functions
Function, standard-quadratic: Public ordinary functions
Function, v*c: Private ordinary functions
Function, v+w*c: Private ordinary functions
fx: Private generic functions
fx: Private generic functions

G
Generic Function, (setf best-before-reshape): Private generic functions
Generic Function, (setf data): Private generic functions
Generic Function, (setf delta): Private generic functions
Generic Function, (setf dmin): Private generic functions
Generic Function, (setf dv): Private generic functions
Generic Function, (setf fk): Private generic functions
Generic Function, (setf fx): Private generic functions
Generic Function, (setf grid-z): Private generic functions
Generic Function, (setf pmap): Private generic functions
Generic Function, (setf x): Private generic functions
Generic Function, (setf xk): Private generic functions
Generic Function, best-before-reshape: Private generic functions
Generic Function, cached-slot: Private generic functions
Generic Function, data: Private generic functions
Generic Function, delta: Private generic functions
Generic Function, dimension: Private generic functions
Generic Function, dmin: Private generic functions
Generic Function, dv: Private generic functions
Generic Function, fk: Private generic functions
Generic Function, fx: Private generic functions
Generic Function, grid-z: Private generic functions
Generic Function, improve: Private generic functions
Generic Function, maybe-fill-simplex: Private generic functions
Generic Function, maybe-reshape: Private generic functions
Generic Function, pmap: Private generic functions
Generic Function, pseudopivot: Private generic functions
Generic Function, q-factor: Private generic functions
Generic Function, r-factor: Private generic functions
Generic Function, restrict: Private generic functions
Generic Function, side-vectors: Private generic functions
Generic Function, sort-simplex: Private generic functions
Generic Function, x: Private generic functions
Generic Function, xk: Private generic functions
grid-z: Private generic functions
grid-z: Private generic functions
grnm-optimize: Public ordinary functions

I
improve: Private generic functions
improve: Private generic functions
initial-simplex: Public ordinary functions
ip: Private ordinary functions

M
Macro, with-matrix-dimensions: Private macros
make-matrix: Private ordinary functions
make-vector: Private ordinary functions
maybe-fill-simplex: Private generic functions
maybe-fill-simplex: Private generic functions
maybe-reshape: Private generic functions
maybe-reshape: Private generic functions
Method, (setf best-before-reshape): Private generic functions
Method, (setf data): Private generic functions
Method, (setf delta): Private generic functions
Method, (setf dmin): Private generic functions
Method, (setf dv): Private generic functions
Method, (setf fk): Private generic functions
Method, (setf fx): Private generic functions
Method, (setf grid-z): Private generic functions
Method, (setf pmap): Private generic functions
Method, (setf x): Private generic functions
Method, (setf xk): Private generic functions
Method, best-before-reshape: Private generic functions
Method, cached-slot: Private generic functions
Method, data: Private generic functions
Method, delta: Private generic functions
Method, dimension: Private generic functions
Method, dmin: Private generic functions
Method, dv: Private generic functions
Method, fk: Private generic functions
Method, fx: Private generic functions
Method, grid-z: Private generic functions
Method, improve: Private generic functions
Method, maybe-fill-simplex: Private generic functions
Method, maybe-reshape: Private generic functions
Method, pmap: Private generic functions
Method, print-object: Public standalone methods
Method, pseudopivot: Private generic functions
Method, q-factor: Private generic functions
Method, r-factor: Private generic functions
Method, restrict: Private generic functions
Method, side-vectors: Private generic functions
Method, sort-simplex: Private generic functions
Method, x: Private generic functions
Method, xk: Private generic functions

N
nm-iteration: Private ordinary functions
nm-iteration-burmen-et-al: Private ordinary functions
nm-optimize: Public ordinary functions
norm: Private ordinary functions

P
pmap: Private generic functions
pmap: Private generic functions
pp-volume-test: Public ordinary functions
print-object: Public standalone methods
pseudopivot: Private generic functions
pseudopivot: Private generic functions

Q
q-factor: Private generic functions
q-factor: Private generic functions
qr-factorization: Private ordinary functions
qrthing-closure: Private ordinary functions

R
r-factor: Private generic functions
r-factor: Private generic functions
regrid: Private ordinary functions
restrict: Private generic functions
restrict: Private generic functions
rosenbrock: Public ordinary functions

S
side-vectors: Private generic functions
side-vectors: Private generic functions
simplex-qr-thing: Private ordinary functions
sort-simplex: Private generic functions
sort-simplex: Private generic functions
standard-quadratic: Public ordinary functions

V
v*c: Private ordinary functions
v+w*c: Private ordinary functions

W
with-matrix-dimensions: Private macros

X
x: Private generic functions
x: Private generic functions
xk: Private generic functions
xk: Private generic functions

Jump to:   (  
B   C   D   F   G   I   M   N   P   Q   R   S   V   W   X  

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

A.3 Variables

Jump to:   *  
B   D   F   P   Q   R   S   X   Z  
Index Entry  Section

*
*biglambda*: Private special variables
*breakdown*: Private special variables
*psi*: Private special variables
*smalllambda*: Private special variables
*tau-a*: Private special variables
*tau-r*: Private special variables
*verbose-level*: Private special variables

B
best-before-reshape: Private classes

D
data: Private classes
delta: Private classes
dmin: Private classes
dv: Private classes

F
fx: Private classes

P
pmap: Private classes
pseudopivot: Private classes

Q
q-factor: Private classes

R
r-factor: Private classes

S
side-vectors: Private classes
Slot, best-before-reshape: Private classes
Slot, data: Private classes
Slot, delta: Private classes
Slot, dmin: Private classes
Slot, dv: Private classes
Slot, fx: Private classes
Slot, pmap: Private classes
Slot, pseudopivot: Private classes
Slot, q-factor: Private classes
Slot, r-factor: Private classes
Slot, side-vectors: Private classes
Slot, x: Private classes
Slot, z: Private classes
Special Variable, *biglambda*: Private special variables
Special Variable, *breakdown*: Private special variables
Special Variable, *psi*: Private special variables
Special Variable, *smalllambda*: Private special variables
Special Variable, *tau-a*: Private special variables
Special Variable, *tau-r*: Private special variables
Special Variable, *verbose-level*: Private special variables

X
x: Private classes

Z
z: Private classes

Jump to:   *  
B   D   F   P   Q   R   S   X   Z