# The linear-programming Reference Manual

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

# The linear-programming Reference Manual

This is the linear-programming Reference Manual, version 2.1.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 05:13:02 2022 GMT+0.

# Common Lisp Linear Programming   This is a Common Lisp library for solving linear programming problems. It's designed to provide a high-level and ergonomic API for specifying linear programming problems as lisp expressions.

The core library is implemented purely in Common Lisp with only a few community-standard libraries as dependencies (ASDF, Alexandria, Iterate). However, the solver is designed to support alternative backends without any change to the user's code. Currently, there is a backend for the GNU Linear Programming Kit (GLPK).

## Installation

The linear-programming library is avalible in both the main Quicklisp distribution and Ultralisp, so it can loaded with with `(ql:quickload :linear-programming)`. You can check that it works by running `(asdf:test-system :linear-programming)`.

If you are not using Quicklisp, place this repository, Alexandria, and Iterate somewhere where ASDF can find them. Then, it can be loaded with `(asdf:load-system :linear-programming)` and tested as above.

## Usage

See neil-lindquist.github.io/linear-programming/ for further documentation.

Consider the following linear programming problem.

maximize x + 4y + 3z
such that

• 2x + y ≤ 8
• y + z ≤ 7
• x, y, z ≥ 0

First, the problem needs to be specified. Problems are specified with a simple DSL, as described in the syntax reference.

``````(use-package :linear-programming)

(defvar problem (parse-linear-problem '(max (= w (+ x (* 4 y) (* 3 z))))
'((<= (+ (* 2 x) y) 8)
(<= (+ y z) 7))))
``````

Once the problem is created, it can be solved with the simplex method.

``````(defvar solution (solve-problem problem))
``````

Finally, the optimal tableau can be inspected to get the resulting objective function, decision variables, and reduced-costs (i.e. the shadow prices for the variable's lower bounds).

``````(format t "Objective value solution: ~A~%" (solution-variable solution 'w))
(format t "x = ~A (reduced cost: ~A)~%" (solution-variable solution 'x) (solution-reduced-cost solution 'x))
(format t "y = ~A (reduced cost: ~A)~%" (solution-variable solution 'y) (solution-reduced-cost solution 'y))
(format t "z = ~A (reduced cost: ~A)~%" (solution-variable solution 'z) (solution-reduced-cost solution 'z))

;; ==>
;; Objective value solution: 57/2
;; x = 1/2 (reduced cost: 0)
;; y = 7 (reduced cost: 0)
;; z = 0 (reduced cost: 1/2)
``````

Alternatively, the `with-solution-variables` and `with-solved-problem` macros simplify some steps and binds the solution variables in their bodies.

``````(with-solution-variables (w x y z) solution
(format t "Objective value solution: ~A~%" w)
(format t "x = ~A (reduced cost: ~A)~%" x (reduced-cost x))
(format t "y = ~A (reduced cost: ~A)~%" y (reduced-cost y))
(format t "z = ~A (reduced cost: ~A)~%" z (reduced-cost z)))

;; ==>
;; Objective value solution: 57/2
;; x = 1/2 (reduced cost: 0)
;; y = 7 (reduced cost: 0)
;; z = 0 (reduced cost: 1/2)

(with-solved-problem ((max (= w (+ x (* 4 y) (* 3 z))))
(<= (+ (* 2 x) y) 8)
(<= (+ y z) 7))
(format t "Objective value solution: ~A~%" w)
(format t "x = ~A (reduced cost: ~A)~%" x (reduced-cost x))
(format t "y = ~A (reduced cost: ~A)~%" y (reduced-cost y))
(format t "z = ~A (reduced cost: ~A)~%" z (reduced-cost z)))

;; ==>
;; Objective value solution: 57/2
;; x = 1/2 (reduced cost: 0)
;; y = 7 (reduced cost: 0)
;; z = 0 (reduced cost: 1/2)
``````

## 2 Systems

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

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

### 2.1 linear-programming

A library for solving linear programming problems

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Version

2.1.1

Dependencies
Source

### 2.2 linear-programming/all

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.3 linear-programming/problem

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.4 linear-programming/conditions

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Source

### 2.5 linear-programming/expressions

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.6 linear-programming/utils

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.7 linear-programming/system-info

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
• iterate (system).
• alexandria (system).
Source

### 2.8 linear-programming/solver

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.9 linear-programming/simplex

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

### 2.10 linear-programming/external-formats

Author

Neil Lindquist <NeilLindquist5@gmail.com>

Contact
Source Control

(GIT https://github.com/neil-lindquist/linear-programming.git)

Bug Tracker

MIT

Dependencies
Source

## 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

#### 3.1.1 linear-programming/linear-programming.asd

Source
Parent Component

linear-programming (system).

ASDF Systems

#### 3.1.2 linear-programming/all/file-type.lisp

Source
Parent Component

linear-programming/all (system).

Packages

#### 3.1.3 linear-programming/problem/file-type.lisp

Source
Parent Component

linear-programming/problem (system).

Packages
Public Interface
Internals

#### 3.1.4 linear-programming/conditions/file-type.lisp

Source
Parent Component

linear-programming/conditions (system).

Packages
Public Interface
Internals

#### 3.1.5 linear-programming/expressions/file-type.lisp

Source
Parent Component

linear-programming/expressions (system).

Packages
Public Interface
Internals

#### 3.1.6 linear-programming/utils/file-type.lisp

Source
Parent Component

linear-programming/utils (system).

Packages
Public Interface
Internals

#### 3.1.7 linear-programming/system-info/file-type.lisp

Source
Parent Component

linear-programming/system-info (system).

Packages
Public Interface

#### 3.1.8 linear-programming/solver/file-type.lisp

Source
Parent Component

linear-programming/solver (system).

Packages
Public Interface

#### 3.1.9 linear-programming/simplex/file-type.lisp

Source
Parent Component

linear-programming/simplex (system).

Packages
Public Interface
Internals

#### 3.1.10 linear-programming/external-formats/file-type.lisp

Source
Parent Component

linear-programming/external-formats (system).

Packages
Public Interface
Internals

## 4 Packages

Packages are listed by definition order.

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

### 4.1 linear-programming/utils

Various internal utilities

Source
Use List

common-lisp.

Used By List
Public Interface
Internals

### 4.2 linear-programming/all

The overall package for the linear programming library. It contains only the reexported symbols of ‘linear-programming/problem‘, ‘linear-programming/solver‘, ‘linear-programming/conditioner‘, and ‘linear-programming/external-formats‘, plus ‘simplex-solver‘ from ‘linear-programming/simplex‘.

Source
Nickname

linear-programming

Use List

### 4.3 linear-programming/solver

The high level linear programming solver interface. This interface is able to wrap multiple backends. The backend can be adjusted by setting the ‘*solver*‘ variable. The default backend is the ‘simplex-solver‘ in the ‘linear-programming/simplex‘ package.

Source
Use List
• common-lisp.
• iterate.
Used By List
Public Interface

### 4.4 linear-programming/simplex

The actual simplex solver implementation for the default solver backend. This package should be used through the interface provided by the ‘linear-programming/solver‘ package.

Source
Use List
Public Interface
Internals

### 4.5 linear-programming/conditions

Contains the various conditions used by this library.

Source
Use List

common-lisp.

Used By List
Public Interface
Internals

### 4.6 linear-programming/system-info

Utilities for inspecting how certain implmenetation-dependant features behave.

Source
Use List
• common-lisp.
• iterate.
Public Interface

### 4.7 linear-programming/problem

Handles the representation of linear programming problems.

Source
Use List
Used By List
Public Interface
Internals

### 4.8 linear-programming/expressions

Contains functions for processing linear expressions.

Source
Use List
Used By List
Public Interface
Internals

### 4.9 linear-programming/external-formats

Handles reading and writing problems to external formats.

Source
Use List
Used By List
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 Constants

Constant: +supported-floats+

Contains the distinct floating point representations supported.

Package
Source

Next: , Previous: , Up: Public Interface   [Contents][Index]

#### 5.1.2 Special variables

Special Variable: *solver*

The function that should be used by solve-problem (defaults to ‘linear-programming/simplex:simplex-solver‘). The function should take a problem, and any backend specific keyword arguments and returns some form of solution object. The solution object should support the following methods ‘solution-problem‘, ‘solution-objective-value‘, ‘solution-variable‘, and ‘solution-reduced-cost‘.

Package
Source

#### 5.1.3 Macros

Macro: make-linear-problem (objective &rest constraints)

Creates a linear problem from the expressions in the body

Package
Source
Macro: with-solution-variables (var-list solution &body body)

Evaluates the body with the variables in ‘var-list‘ bound to their values in the solution. Additionally, the macro ‘reduced-cost‘ is locally bound that takes a variable name and provides it’s reduced cost.

Package
Source
Macro: with-solved-problem ((objective-func &rest constraints) &body body)

Takes the problem description, and evaluates ‘body‘ with the variables of the problem bound to their solution values. Additionally, the macro ‘reduced-cost‘ is locally bound that takes a variable name and provides it’s reduced cost.

Package
Source
Macro: with-tableau-variables (var-list tableau &body body)

Evaluates the body with the variables in ‘var-list‘ bound to their values from the tableau.

Package
Source

#### 5.1.4 Compiler macros

Compiler Macro: fp< (a b &optional factor)
Package
Source
Compiler Macro: fp<= (a b &optional factor)
Package
Source
Compiler Macro: fp> (a b &optional factor)
Package
Source
Compiler Macro: fp>= (a b &optional factor)
Package
Source

#### 5.1.5 Ordinary functions

Function: build-tableau (problem instance-problem &key fp-tolerance-factor)

Creates the tableau from the given linear problem. If the trivial basis is not feasible, instead a list is returned containing the two tableaus for a two-phase simplex method.

Package
Source
Function: copy-tableau (tableau)

Copies the given tableau and it’s matrix.

Package
Source
Function: float-contagion (t1 t2)

Computes the representation type using the rules for float contagion.

Package
Source
Function: format-linear-expression (alist)

Formats a linear expression as a sexp.

Package
Source
Function: fp< (a b &optional factor)

Tests for inequality taking into account floating point error. ‘factor‘ is the acceptable multiple of unit round off that the two values can differ by.

Package
Source
Function: fp<= (a b &optional factor)

Tests for inequality taking into account floating point error. ‘factor‘ is the acceptable multiple of unit round off that the two values can differ by.

Package
Source
Function: fp= (a b &optional factor)

Tests for equality taking into account floating point error. ‘factor‘ is the acceptable multiple of unit round off that the two values can differ by.

Package
Source
Function: fp> (a b &optional factor)

Tests for inequality taking into account floating point error. ‘factor‘ is the acceptable multiple of unit round off that the two values can differ by.

Package
Source
Function: fp>= (a b &optional factor)

Tests for inequality taking into account floating point error. ‘factor‘ is the acceptable multiple of unit round off that the two values can differ by.

Package
Source
Function: lb-max (x y)

Computes the maximum value where nil is negative infinity

Package
Source
Function: lb-min (x y)

Computes the minimum value where nil is negative infinity

Package
Source
Function: n-pivot-row (tableau entering-col changing-row)

Destructively applies a single pivot to the table.

Package
Source
Function: n-solve-tableau (tableau)

A non-consing version of [‘solve-tableau‘](#function-linear-programming/simplex:solve-tableau).

Package
Source
Function: optimization-type (x)

Gets the type of ‘x‘ to optimize for. If ‘x‘ is a rational, returns ‘rational‘. Otherwise, returns the type of ‘x‘.

Package
Source
Function: parse-linear-expression (expr)

Parses the expression into a alist mapping variables to coefficients. Any constant values are mapped to ‘+constant+‘.

Package
Source
Function: parse-linear-problem (objective-exp constraints)

Parses the expressions into a linear programming problem

Package
Source
Function: pivot-row (tableau entering-col changing-row)

Non-destructively applies a single pivot to the table.

Package
Source

A list of (in)equality constraints.

Package
Source
Target Slot

A list of variables with integer constraints.

Package
Source
Target Slot

The objective function as a linear expression alist.

Package
Source
Target Slot

The name of the objective function.

Package
Source
Target Slot

Whether the problem is a ‘min‘ or ‘max‘ problem.

Package
Source
Target Slot

type.

A list of variable bounds, of the form ‘(var . (lower-bound . upper-bound))‘.

Package
Source
Target Slot

An array of the variables specified in the problem.

Package
Source
Target Slot

vars.

Function: read-mps (stream problem-type &key package read-case trim-names-p number-type rhs-id)

Reads a problem in MPS format from the given stream. Note that a line starting with ‘ENDATA‘ ends the problem, so MPS files can be embedded in streams of other data. Only the fixed width version of the format is supported, but both the ‘OBJSENCE‘ and ‘OBJNAME‘ headers are supported and the ‘BV‘, ‘LI‘, and ‘UI‘ boundaries are supported.

Package
Source

Loads a problem stored in sexp format. This is a single sexp with the first element being the objective function and the rest of the elements being the constraints. Note that normally ‘*read-eval*‘ is bound to ‘nil‘, but can be enabled with ‘allow-read-eval‘; however, this should only be done when parsing trusted data.

Package
Source
Function: scale-linear-expression (expr scalar)

Multiplies the linear expression by the given scalar.

Package
Source
Function: simplex-solver (problem &rest args)

The solver interface function for the simplex backend. The ‘fp-tolerance‘ keyword argument can be used to indicate the tolerance for error on floating point comparisons (defaults to 1024).

Package
Source
Function: solve-problem (problem &rest args &key &allow-other-keys)

Solves the given problem using the function stored by ‘*solver*‘. Any keyword arguments are passed to the solver function.

Package
Source
Function: solve-tableau (tableau)

Attempts to solve the tableau using the simplex method. If a list of two tableaus is given, then a two-phase version is used. The original tableau(s) are unchanged.

Package
Source
Function: sum-linear-expressions (&rest exprs)

Takes linear expressions and reduces it into a single expression.

Package
Source
Package
Source
Target Slot
Package
Source
Target Slot
Package
Source
Target Slot
Package
Source
Target Slot
Function: tableau-objective-value (tableau)

Gets the objective function value in the tableau.

Package
Source
Function: tableau-p (object)
Package
Source
Package
Source
Target Slot
Function: tableau-reduced-cost (tableau var)

Gets the reduced cost (i.e. the shadow price for the lower bound) for the given variable from the tableau.

Package
Source
Package
Source
Target Slot
Function: tableau-variable (tableau var)

Gets the value of the given variable from the tableau

Package
Source
Function: ub-max (x y)

Computes the maximum value where nil is positive infinity

Package
Source
Function: ub-min (x y)

Computes the minimum value where nil is positive infinity

Package
Source
Function: validate-bounds (lb ub var)

Checks that the bounds represent a non empty range

Package
Source
Function: write-sexp (stream problem &key package)

Writes the problem as a sexp. The first element is the objective function and the rest of the elements are the constraints.

Package
Source
Function: write-standard-format (stream problem &key unicodep aesthetic-variable-names-p)

Writes a problem to the given stream in human readable, standard notation. The ‘unicodep‘ argument controls whether to print comparisons as unicode or ascii. The ‘aesthetic-variable-names-p‘ argument controls whether variable names are printed aesthetically.

Package
Source

#### 5.1.6 Generic functions

Generic Function: solution-objective-value (solution)

Gets the value of the objective function.

Package
Source
Methods
Method: solution-objective-value ((solution tableau))
Generic Function: solution-problem (solution)

Gets the original problem for the solution.

Package
Source
Methods
Method: solution-problem ((solution tableau))
Generic Function: solution-reduced-cost (solution variable)

Gets the reduced cost of the specified variable. This is the
amount that the objective coefficient for the variable must increase or decrease, for maximization and minimization problems respectively, before the given variable appears in an optimal solution.

Package
Source
Methods
Method: solution-reduced-cost ((solution tableau) variable)
Generic Function: solution-variable (solution variable)

Gets the value of the specified variable.

Package
Source
Methods
Method: solution-variable ((solution tableau) variable)

#### 5.1.7 Conditions

Condition: infeasible-integer-constraints-error

Indicates that there is no feasible region due to the integer constraints.

Package
Source
Direct superclasses
Condition: infeasible-problem-error

Indicates the there is no feasible region.

Package
Source
Direct superclasses
Direct subclasses
Condition: invalid-bounds-error

Indicates a problem with a variable’s bounds.

Package
Source
Direct superclasses
Direct methods
Direct slots
Slot: var
Initargs

:var

var.

Writers

This slot is read-only.

Slot: ub
Initargs

:ub

ub.

Writers

This slot is read-only.

Slot: lb
Initargs

:lb

lb.

Writers

This slot is read-only.

Condition: nonlinear-error

Indicates a form was not a linear expression. This includes the use of nonlinear functions and taking the product of multiple variables

Package
Source
Direct superclasses
Direct methods
Direct slots
Slot: expression

Contains the problematic expression

Initargs

:expression

Writers

This slot is read-only.

Condition: parsing-error

Indicates an error occured while parsing a linear problem. Includes a textual description of the issue.

Package
Source
Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: description
Initargs

:description

Writers

This slot is read-only.

Condition: solver-error

The base class for errors that occur with the solving algorithm.

Package
Source
Direct superclasses

error.

Direct subclasses
Condition: unbounded-problem-error

Indicates the feasible region is unbounded such that the optimal objective value is infinite.

Package
Source
Direct superclasses
Condition: unsupported-constraint-error

Indicates there are unsupported constraints or properties in the given problem.

Package
Source
Direct superclasses
Direct methods
Direct slots
Slot: constraint
Initargs

:constraint

Writers

This slot is read-only.

Slot: solver-name
Initargs

:solver-name

Writers

This slot is read-only.

Previous: , Up: Public Interface   [Contents][Index]

#### 5.1.8 Structures

Structure: problem

The representation of a linear programming problem.

Package
Source
Direct superclasses

structure-object.

Direct slots
Slot: type
Package

common-lisp.

Type

(member max min)

Initform

(quote max)

Writers

This slot is read-only.

Slot: vars
Type

(simple-array symbol (*))

Initform

#()

Writers

This slot is read-only.

Slot: objective-var
Type

symbol

Initform

(quote #:z)

Writers

This slot is read-only.

Slot: objective-func
Type

list

Writers

This slot is read-only.

Slot: integer-vars
Type

list

Writers

This slot is read-only.

Slot: var-bounds
Type

list

Writers

This slot is read-only.

Slot: constraints
Type

list

Writers

This slot is read-only.

Structure: tableau

Contains the necessary information for a simplex tableau.

Package
Source
Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: problem
Package
Type

linear-programming/problem:problem

Writers

This slot is read-only.

Slot: instance-problem
Type

linear-programming/problem:problem

Writers

This slot is read-only.

Slot: matrix
Type

(simple-array real 2)

Initform

#2a()

Writers

This slot is read-only.

Slot: basis-columns
Type

(simple-array fixnum (*))

Initform

#()

Writers

This slot is read-only.

Slot: var-count
Type

(and fixnum unsigned-byte)

Initform

0

Writers

This slot is read-only.

Slot: constraint-count
Type

(and fixnum unsigned-byte)

Initform

0

Writers

This slot is read-only.

Slot: var-mapping
Type

hash-table

Initform

(make-hash-table :test (function eq))

Writers

This slot is read-only.

Slot: fp-tolerance-factor
Type

real

Initform

1024

Writers

This slot is read-only.

### 5.2 Internals

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

#### 5.2.1 Macros

Macro: fp-inequality (name op eps-mod)
Package
Source

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

#### 5.2.2 Ordinary functions

Function: build-and-solve (problem extra-constraints &key fp-tolerance-factor)

Builds and solves a tableau with the extra constrains added to the problem.

Package
Source
Function: copy-problem (instance)
Package
Source
Function: find-entering-column (tableau)

Gets the column to add to the basis.

Package
Source
Function: find-pivoting-row (tableau entering-col)

Gets the column that will leave the basis.

Package
Source
Function: gen-entries (tableau entry)

Generates new entries to correct one of the integer constraints.

Package
Source
Function: linear-constant-p (expr)

A predicate for whether a linear expression is constant.

Package
Source
Function: make-problem (&key type vars objective-var objective-func integer-vars var-bounds constraints)
Package
Source
Function: make-tableau (&key problem instance-problem matrix basis-columns var-count constraint-count var-mapping fp-tolerance-factor)
Package
Source
Function: newlinep (c)

Predicate if the given character is a newline or return

Package
Source
Function: parse-linear-constraints (exprs)

Parses the list of constraints and returns a list containing a list of simple inequalities and a list of integer variables.

Package
Source
Function: print-linear-expression (stream expression &optional aesthetic-variable-names-p)
Package
Source
Function: problem-p (object)
Package
Source
Function: read-until (stream test &optional preview-test)

Reads the given stream until the condition is true. ‘test‘ can either be a predicate that takes one argument, or a character to be tested using ‘char=‘.

Package
Source
Function: sum-linear-expressions-list (exprs)

Takes a list of linear expressions and reduces it into a single expression.

Package
Source
Package
Source
Target Slot
Package
Source
Target Slot
Function: violated-integer-constraint (tableau)

Gets a variable that is required to be an integer but is currently violating that constraint.

Package
Source

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

#### 5.2.3 Generic functions

Generic Reader: constraint (condition)
Package
Methods
Reader Method: constraint ((condition unsupported-constraint-error))
Source
Target Slot
Generic Reader: description (condition)
Package
Methods
Reader Method: description ((condition parsing-error))
Source
Target Slot
Generic Reader: lb (condition)
Package
Methods
Reader Method: lb ((condition invalid-bounds-error))
Source
Target Slot

lb.

Generic Reader: nonlinear-expression (condition)
Package
Methods
Reader Method: nonlinear-expression ((condition nonlinear-error))
Source
Target Slot
Generic Reader: solver-name (condition)
Package
Methods
Reader Method: solver-name ((condition unsupported-constraint-error))
Source
Target Slot
Generic Reader: ub (condition)
Package
Methods
Reader Method: ub ((condition invalid-bounds-error))
Source
Target Slot

ub.

Generic Reader: var (condition)
Package
Methods
Reader Method: var ((condition invalid-bounds-error))
Source
Target Slot

var.

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

#### 5.2.4 Types

Type: lb ()
Package
Source
Type: ub ()
Package
Source
Type: var-mapping-entry ()

Represents a maping from a problem’s variable to a set of columns in the tableau.

Package
Source