Contents

LINDO Help System Contents

What Is LINDO?

Entering a Small Model

Model Syntax

Optional Modeling Statements

Real-World Example

LINDO Menus and Commands

Error Message Listing

… click on any of the topics above for more information …


What Is LINDO?

LINDO (Linear, INteractive, and Discrete Optimizer) is a convenient but powerful tool for solving linear, integer, and quadratic programming problems. These problems occur in areas of business, industry, research and government.  Specific applications areas where LINDO has proven to be of great use would include product distribution, ingredient blending, production and personnel scheduling, inventory management ... we will stop here, but the list could easily go on indefinitely.

The guiding design philosophy for LINDO has been that if a user wants to do something simple, then there should not be a large setup cost to learn the necessary features of LINDO.  If, for example, a users wishes to:

Maxmize 2X + 3Y

Subject to

4X + 3Y < 10

3X + 5Y < 12

then that is exactly what the user types into LINDO immediately after starting the program.

At the other extreme, LINDO has been used to solve real industrial linear, quadratic, and integer programs of respectable size.  On large machines, it has been used to solve problems with over 50,000 constraints and 200,000 variables.

There are three basic styles of using the LINDO software.  For small to medium sized problems, LINDO is simple to use interactively from the keyboard; entering a model is quite easy to do. It is also possible to use LINDO with files created elsewhere,  containing scripts of commands and input data, and producing files for reporting purposes. Finally, custom-created subroutines may be linked directly with LINDO to form an integrated program containing both your code and the LINDO optimization libraries.

Click here to learn how to enter a small example.


Entering A Model in Windows
Entering A Model

We now illustrate how to input and solve a small model.  When you start LINDO, your screen should resemble the following:

The outer window labeled "LINDO" is the main frame window.  All other windows will be contained within this window.  The frame window also contains all the command menus and the command toolbar.  The smaller child window labeled "<untitled>" is a new, blank model window.  We will type our sample model directly into this window, but first we need to briefly discuss the basic requirements of a LINDO model.

A LINDO model has a minimum requirement of three things. It needs an objective, it needs variables, and it needs constraints.

The first requirement, an objective, is just what it sounds like: a goal. You have the choice of two goals, MAX or MIN, which stand for maximize and minimize. In a typical business situation, for instance, you might want to maximize profit or minimize cost. The first word in a LINDO model must be either MAX or MIN.

The formula you enter after the MAX or MIN is called the objective function. For our purposes, we will assume you want to maximize profit. You enter:

MAX  10 X + 15 Y

followed by a return.

But what are X and Y? They are variables, which are things you want LINDO to adjust to reach your maximum profit. They could represent total sales of two products, or sales out of two different offices; in this case X has a profit contribution of 10, and Y has a profit contribution of 15. The important thing is that they are variable. In LINDO, the minute you use a variable in your model, it exists. You do not have to do anything other than enter it in a formula.

So much for the objective and two variables. Now we will look at constraints. In some ways, constraints are the most important part of your model, and they require some real thinking.

In the little example we are considering, if you were to maximize 10X + 15Y now, there is no limit to how many of both X and Y you could sell. Of course there must be some limit; in the real world, that may be factory output and labor availability, for instance. So we will constrain both X and Y to be less than an arbitrary factory capacity. You do this by entering the words SUBJECT TO on the next line of your model (or just the letters ST) and on the line after that, entering

X < 10

and

Y < 12

on the following two lines.  Note that LINDO interprets the < symbol as meaning "less than or equal to" rather than "strictly less than".  If you prefer, you may alternatively enter <= in place of the < character.

Very well, we have constrained X and Y now. Suppose that we also have a limited labor supply.  In particular, assume that we have a total of 16 units of labor and that product X requires one unit of labor while product Y is relatively more labor intense and requires 2 units of labor.  We now add the following labor constraint

X + 2 Y < 16

on the next line, and, finally, on the line after that we designate the end of the constraints by adding

END

After entering the above, your screen should look like this:

Your model has now been entered and it is ready to be solved.  To begin solving the model, select the Solve command from the Solve menu, or press the Solve button ( [image]) on the toolbar at the top of the window.  LINDO will begin by trying to compile the model.  This means LINDO will determine whether the model makes mathematical sense, and whether it conforms to syntactical requirements. If the model does not pass these tests, you will be informed with the following error message:

An error occurred during compilation on line: n

LINDO will then jump to the line where the error occurred.  You should examine this line for any syntax errors and correct them.

If there are no formulation errors during the compilation phase, LINDO will then begin to actually solve the model.  When the LINDO solver initiates it displays a Status Window on your screen that looks like the following:

This Status Window is useful for monitoring the progress the solver.  A description of the various fields and controls within the status appear in the table below.

Field/Control	Description
Status	Gives status of current solution.  Possible values include: Optimal, Feasible, Infeasible, Unbounded.
Iterations	Number of solver iterations.
Infeasibility	Amount by which constraints are violated.
Objective	Current value of the objective function.
Best IP	Objective value of best integer solution found.  Only relevant in integer programming (IP) models.
IP Bound	Theoretical bound on the objective for IP models.
Branches	The number of integer variables "branched" on by the LINDO IP solver.
Elapsed Time	Elapsed time since the solver was invoked.
Update Interval	The frequency (in seconds) that the Status Window is updated.  You can set this to any nonnegative value desired.  Setting the interval to zero will tend to increase solution times.
Interrupt Solver	Press this button to interrupt the solver at any point and have it return the current best solution found.
Close	Press this button to close the Status Window. Optimization will continue.  The Status Window may be reopened by selecting the Status Window command from the Window menu.
When the solver is finished it will prompt you to determine if you wish to do sensitivity and range analysis.  Eventually, you will be able to make use of this information, but for now, just press the "No" button and then close the Status Window.

There will now be a new window on your screen titled "Reports Window".  The Reports Window is where LINDO sends all text based reporting output.  The window can hold up to 64,000 characters of information.  If required, LINDO will erase output from the top of the Reports Window in order to make room for new output at the bottom of the window.  If you have a lengthy solution report that you need to examine in its entirety, you can log all information sent to the Report Window in a disk file using the File|Log Output command.  This file can then be examined using an external text editor or using the File|View command.

Getting back to our example,  the Reports Window now contains the solution to our model, and should resemble the following:

Taken in order, this tells you, first, that LINDO took 2 iterations to solve the model; second, that the maximum profit attainable from the two variables, as you have constrained them, is 145. Third, the variables X and Y take the values 10 and 3 respectively. What is interesting to note is that we make less of the relatively more "profitable" Y due to its intensive use of our limited supply of labor.

Click here for information on the REDUCED COSTS, SLACK OR SURPLUS and DUAL PRICES sections in the solution report.


Model Syntax

This section details the syntax required in a LINDO model.  Fortunately, the list of rules is rather short and easy to learn.

The objective function must always be at the start of the model and is initiated with either MAX (for maximize) or MIN (for minimize). The end of the objective function and the beginning of the constraints is signified with any of the following:

SUBJECT TO

SUCH THAT

S.T.

ST

The end of the constraints is signified with the word END.

LINDO has a limit of eight characters in a variable name.  Names must begin with an alphabetic character (A to Z), which may then be followed by up to seven additional characters.  These additional characters may include anything with the exception of the following: ! ) + - = < >.  So, as an example, the following names would be considered valid:

XYZ	MY_VAR	A12	SHIP.LA

whereas the following would not:

THISONESTOOLONG	A-HYPHEN	1INFRONT

The first example contains more than eight characters, while the second contains a forbidden hyphen, and the last example does not begin with an alphabetic character.

You may, optionally, name constraints in a model.  Constraint names make many of LINDO's output reports easier to interpret.  Constraint names must follow the same conventions as variable names.  To name a constraint you must start the constraint with its name terminated with a right parenthesis.  After the right parenthesis, you continue entering the constraint as before.  As an example, the following constraint is given the name XBOUND:

XBOUND) X < 10

LINDO recognizes only five operators: plus (+), minus (-), greater than (>), less than (<), and equals (=). When you enter the strict inequality operators, greater than (>) or less than (<), LINDO will interpret them with the loose inequality operators > or < respectively. This is because many keyboards do not have the loose inequality operators. On systems that do have the loose operators, LINDO will not recognize them.  However, if you prefer, you may enter ">=" (and "<=") in place of ">" (and "<").

LINDO will not accept parentheses as indicators of a preferred order of precedence. All operations in LINDO are ordered from left to right.

Comments may be placed anywhere in a model.  A comment is denoted by an exclamation mark (!).  Anything following the exclamation mark on the current line will be considered a comment.  For example,  the small example discussed earlier in this chapter is recast below using comments:

MAX 10 X + 15 Y   ! Max profit

SUBJECT TO

! Here are our factory capacity constraints

! for brands X and Y

X < 10

Y < 12

! Here is the constraint on labor availability

X + 2 Y < 16

END

Command-line versions of LINDO allow you to input comments, but they will not be stored with the model.  Comments are preserved in Windows versions of LINDO as long as the file is saved in text format.  Saving the file in either compressed (*.LPK) or MPS format (*.MPS) will cause comments and any special formatting to be stripped from the model.

Constraints and objective functions may be split over multiple lines, or combined on single lines.  You may spilt a line anywhere except in the middle of a variable name or a coefficient.   The following would be mathematically equivalent to our example (although not quite as easy to read):

MAX

10

X  + 15 Y  SUBJECT TO

X

<

10

y < 12  X + 2

y < 16 end

LINDO is not case sensitive. All input is converted to upper case internally by LINDO. For example, the following model is valid:

Max x

st

X < 1

eNd

and contains a single variable X rather than the two variables x and X.

Only constant values, not variables, are permitted on the right-hand side of a constraint equation. Thus, an entry such as:

X > Y

would be rejected by LINDO. Such an entry could be made as:

X - Y > 0

Conversely, only variables and their coefficients are permitted on the left-hand side of constraints.  For instance, the constraint:

3X + 4Y - 10 = 0

is not permitted due to the constant term of -10 on the left-hand side.  Of course, the constraint may be recast as:

3X + 4Y = 10

in order to comply with LINDO syntax.

Click here to jump to a discussion on additional, optional modeling statements recognized by LINDO.


Optional Modeling Statements

In addition to the three required model components of an objective function, variables, and constraints; LINDO also has a number of other optional modeling statements that may appear after the END statement in a model.  In command-line versions of LINDO, you enter these statements as system commands to the command level prompt (:) after the END statement terminating the model's constraints.  In Windows versions of LINDO the statements should be entered as part of the model text after the END statement in the model window.  These statements and their functions appear in the table below:

Model Statement	Function
FREE <Variable>	Removes all bounds on <Variable>, allowing <Variable> to take on any real value, positive or negative.
GIN <Variable>	Makes <Variable> a general integer (i.e., restricts it to the set of nonnegative integers).
INT <Variable>	Makes <Variable> binary (i.e., restricts it to be either 0 or 1).
SLB <Variable> <Value>	Places a simple lower bound on <Variable> of <Value>.  Use in place of constraints of form X  r.
SUB <Variable> <Value>	Places a simple upper bound on <Variable> of <Value>.  Use in place of constraints of form X  r.
QCP <Constraint>	Marks the beginning of the "real" constraints in a quadratic programming model.
TITLE <Title>	Makes <Title> the title of the model.
Next, we will briefly illustrate the use of each of these statements.


FREE STATEMENT

The default lower bound for a variable is 0.  In other words, unless you specify otherwise, LINDO will not let a variable go negative.  The FREE statement allows you to remove all bounds on a variable so that it may take on any real value, positive or negative.  The following example illustrates the use of the FREE statement.

Had we not set Y to be a free variable in this example, LINDO would not have found the optimal solution of X = 6 and Y= -1;  instead,  given the default lower bound of 0 on Y, LINDO would have returned the solution X = 7 and Y = 0.


GIN STATEMENT

By default, LINDO assumes that all variables are continuous.  In many applications,  fractional values may be of little use (e.g., 2.5 employees).  In these instances, you will want to make use of the general integer statement - GIN.  GIN followed by a variable name restricts the value of the variable to the nonnegative integers (0,1,2,…).  The following small example illustrate the use of the GIN statement.

Had we not specified X and Y to be general integers in this model, LINDO would not have found the optimal solution of X = 6 and Y = 0.   Instead, LINDO would have treated X and Y as continuous and returned the solution of X = 5.29 and Y = 1.43.

Note also, that simply rounding the continuos solution to the nearest integer values does not yield the optimal solution in this example.  In general, rounded continuous solutions may be nonoptimal and, at worst, infeasible.  Based on this, one can imagine that it can be very time consuming to obtain the optimal solution to a model with many integer variables.  In general, this is true, and you are best off utilizing the GIN feature only when absolutely necessary.

As a final note, the GIN command also accepts an integer value argument in place of a variable name.  The number corresponds to the number of variables you want to be general integers.  These variable must appear first in the formulation.  Thus, in this simple example, we could have replaced our two GIN statements with the single statement: GIN 2.


INT STATEMENT

Using INT restricts a variable to being either 0 or 1.  These variables are often referred to as binary variables.  In many applications,  binary variables can be very useful in modeling all-or-nothing situations.  Examples might include such things as taking on a fixed cost, building a new plant, or buying a minimum level of some resource to receive a quantity discount.  For more information on the many useful applications of binary variables you can refer to the LINDO textbook, Optimization Modeling with LINDO.

The following small examples illustrate the use of the INT .

Had we not specified X to be binary in this example, LINDO would have returned a solution of X = .4, A = 4, and B = 7 for an objective value of 124.   Forcing X to be binary, you might guess that the optimal solution would be for X to be 0 because .4 is closer to 0 than it is to 1.  If we round X to 0 and optimize for A and B we get an objective of 84.  In reality, a considerably better solution is obtained at X = 1,  A = 10, and B = 1 for an objective of 112.

In general, rounded continuous solutions may be nonoptimal and, at worst, infeasible.  Based on this, one can imagine that it can be very time consuming to obtain the optimal solution to a model with many binary variables.  In general, this is true and you are best off utilizing the INT feature only when absolutely necessary.

As a final note, the INT command also accepts an integer value argument in place of a variable name.  The number corresponds to the number of variables you want to be general integers.  These variable must appear first in the formulation.


SUB AND SLB STATEMENTS

If you do not specify otherwise, LINDO assumes that variables are continuous, bounded below by zero, and unbounded from above.  In many applications,  this assumption may not be realistic.  Suppose your facilities limit the quantity produced of an item.  In this case, the variable that represents the quantity produced is bounded from above.  Or, suppose you want to allow for backordering in a system.  An easy way to model this is to allow an inventory variable to go negative.  In which case, you would like to circumvent the default lower bound of zero.  The SUB and SLB statements are used to alter the bounds on a variable.  SLB stands for Simple Lower Bound and is used to set lower bounds.  Similarly, SUB stands for Simple Upper Bound and is used to set upper bounds.

The following small examples illustrate the use of the SUB and SLB statements.

In this example, we could have just as easily used constraints to represent the bounds.  Specifically, we could have entered our small model as follows:

max 20x + 30y

st

   x + 2y < 120

   x > 20

   x < 50

   y > 40

   y < 70

end

Of course, this formulation would yield the same results, but there are two points to keep in mind.  First off, SUBs and SLBs are handled implicitly by the solver, and, therefore, are more efficient from a performance point of view than constraints.  Secondly, SUBs and SLBs do not count against the constraint limit in LINDO, allowing you to solve larger models within the limits of your version of LINDO.


QCP STATEMENT

The QCP statement is used in quadratic programming models to indicate the first "real" constraint, as opposed to the first order condition constraints.  The details of formulating a quadratic program are somewhat involved, and the reader is asked to refer the documentation for more information on formulating quadratic programs.  However, we will briefly demonstrate here how QCP is incorporated into a model.

The following small portfolio model illustrates the use of the QCP statement.


TITLE STATEMENT

This statement is used to associate a title with a model.  The title may be any alphanumeric string of up to 74 characters in length.  The title of the current model may be displayed using the File|Title command.  Unlike all the other statements which must appear after the END statement, the Title statement may appear before the objective or after the END statement of a model.

Here is an example of a small model with a title:

When we issue the Title command from the File menu, the model's title is sent to the Reports Window as follows:


A Real-World Example

In this next section we develop a small staff scheduling example and delve a little more deeply into the details of the LINDO solution report.  Although this model is still quite small, it is, perhaps, our first example of a potential real-world application.

Let's say you operate a retail business. You want to know how many clerks you need to hire, and what days to assign them to, to minimize your labor cost while meeting your needs at the store. There are two limiting factors that govern how many people you hire and what days they work.

First, each of your workers receives $300 per week for a regular schedule, with $25 extra for Saturday work and $35 extra for Sunday work.  Each worker can work only five days a week, and must have two consecutive days off.

Second, you have minimum staffing needs which must be met. In table form, that requirement looks like this:

DAY	M	T	W	Th	F	S	Su

REQ	20	13	10	12	16	18	20

Under the restrictions outlined above, the following schedules are available, with varying weekly pay rates (where the symbol ( · ) denotes a day worked):

Schedule  Start Day	Mon	Tue	Wed	Thu	Fri	Sat	Sun	Weekly  Pay $
Mon								300
Tue								325
Wed								360
Thu								360
Fri								360
Sat								360
Sun								335
Here's how this information translates into a LINDO model.  First, let's determine what the objective will be. If you want to minimize your cost, that means minimizing the sum of all weekly salaries paid. If you have a variable called MWORK that represents the number of workers who start on Monday, and the salary for that shift is $300, then 300 * MWORK is the amount paid to those Monday-Start workers. Similarly, TWORK can represent Tuesday-Start workers; and 325 * TWORK, according to the table above, is the amount paid to the those workers. Proceeding through the week, you can formulate your objective like this:

MIN 300 MWORK + 325 TWORK + 360 WWORK + 360 THWORK

    + 360 FWORK + 360 SWORK + 335 SUWORK

But if you were to solve the model right now, the solution would minimize to zero; obviously, everything else being equal, it's cheapest to hire nobody at all!  So you have to constrain each day's labor force to meet the daily staffing requirement.  We indicate the beginning of our constraint set by typing:

SUBJECT TO

Each day, the number of workers on each shift that covers that day will have to be at least as great as the minimum required for that day. On Monday, for instance, 20 workers are the minimum, so:

MON) MWORK + THWORK + FWORK + SWORK + SUWORK >= 20

Notice that the variables TWORK and WWORK do not appear in this constraint. This is because workers who start on Tuesday and Wednesday are not on duty on Monday.  Note, also, that we have made use of the row naming feature and have assigned this row the name MON.

Moving down through the week, the rest of the constraints are:

TUE) MWORK + TWORK                  + FWORK + SWORK + SUWORK > 13

WED) MWORK + TWORK + WWORK                  + SWORK + SUWORK > 10

THU) MWORK + TWORK + WWORK + THWORK                 + SUWORK > 12

FRI) MWORK + TWORK + WWORK + THWORK + FWORK                  > 16

SAT)         TWORK + WWORK + THWORK + FWORK + SWORK          > 18

SUN)                 WWORK + THWORK + FWORK + SWORK + SUWORK > 20

Finally, we denote the end of the model by typing: END.  In summary, the model, in its entirety is as follows:

MIN 300 MWORK + 325 TWORK + 360 WWORK + 360 THWORK

    + 360 FWORK + 360 SWORK + 335 SUWORK

SUBJECT TO

MON) MWORK                 + THWORK + FWORK + SWORK + SUWORK > 20

TUE) MWORK + TWORK                  + FWORK + SWORK + SUWORK > 13

WED) MWORK + TWORK + WWORK                  + SWORK + SUWORK > 10

THU) MWORK + TWORK + WWORK + THWORK                 + SUWORK > 12

FRI) MWORK + TWORK + WWORK + THWORK + FWORK                  > 16

SAT)         TWORK + WWORK + THWORK + FWORK + SWORK          > 18

SUN)                 WWORK + THWORK + FWORK + SWORK + SUWORK > 20

END

Now you are ready to solve the model.  In Windows versions of LINDO, press the Solve button ( [image]) on the toolbar at the top of the frame window; in command-line versions give the GO command.  LINDO will solve the model and return the following solution:

         OBJECTIVE FUNCTION VALUE

           1)      7750.000

  VARIABLE        VALUE          REDUCED COST

     MWORK         2.000000          0.000000

     TWORK         0.000000        100.000000

     WWORK         2.000000          0.000000

    THWORK         7.000000          0.000000

     FWORK         5.000000          0.000000

     SWORK         4.000000          0.000000

    SUWORK         2.000000          0.000000

       ROW   SLACK OR SURPLUS     DUAL PRICES

      MON)         0.000000       -100.000000

      TUE)         0.000000          0.000000

      WED)         0.000000       -100.000000

      THU)         1.000000          0.000000

      FRI)         0.000000       -100.000000

      SAT)         0.000000        -25.000000

      SUN)         0.000000       -135.000000

 NO. ITERATIONS=       8

Your weekly salary cost is minimized to $7750, and all staffing needs have been met. You need to start 2 people on Monday, nobody on Tuesday, 2 on Wednesday, 7 on Thursday, 5 on Friday, 4 on Saturday, and 2 on Sunday to meet your requirements.

But there's more in the solution report than just an optimal objective. If you'll look in the row titled THU), you'll see that there's a slack of 1 returned on that constraint. That means that in order to satisfy all the requirements of the model, LINDO had to have one more person than required available on Thursday. Overstaffing always seems wasteful, but because of uneven staffing requirements, sometimes it is unavoidable.

Click here for additional discussion on the interpretation of LINDO solution reports …


Slack or Surplus

The SLACK OR SURPLUS column in a LINDO solution report tells you how close you are to the right-hand side (RHS) limit on each constraint. This quantity, on less-than-or-equal () constraints, is generally referred to as slack, while on greater-than-or-equal () constraints it is called a surplus. If a constraint is exactly satisfied as an equality, the SLACK OR SURPLUS value will be zero. If a constraint is violated, as in an infeasible solution, the SLACK OR SURPLUS value will be negative. Knowing this can help you find the violated constraints in an infeasible model.


Reduced Costs

In a LINDO solution report, you'll find a REDUCED COST figure for each variable. There are two valid, equivalent interpretations of a reduced cost.

First, you may interpret a variable's reduced cost as the amount by which the objective coefficient of the variable would have to improve before it would become profitable to bring that variable into the solution at a nonzero value.  In the staffing example we've been looking at, only the variable TWORK is not in the solution: no workers start on Tuesday. The reduced cost of 100 for TWORK means that TWORK's objective coefficient of  325 would have to improve (in this case, decrease, which is an improvement in a minimization problem) by at least 100 before TWORK would appear in the solution. (A reduced cost of zero, as in the case of MWORK, for instance, indicates that the variable is already in the solution.)

Second, the reduced cost may be interpreted as the amount of penalty you would have to pay to introduce a variable into the solution.

Reduced costs are valid only over a range of values.  LINDO provides a Range Analysis facility for determining the valid ranges of the reduced costs.


Dual Prices

The LINDO solution report also gives a DUAL PRICE figure for each constraint. You can interpret the dual price as the amount by which the objective would improve given a unit of increase in the right-hand side of the constraint.

Notice that "improve" is a relative term. In a minimization problem such as our example, interpreting the dual price requires some thought. The dual price on the FRI constraint, for example, is -100. This means that raising the right-hand side of the FRI constraint by one unit would cause the objective to "improve" by negative 100: that is, it would increase by 100.  Or, the marginal cost of providing one additional staff member on Fridays would be $100 in additional salary expense.

Dual prices are sometimes called shadow prices, because they tell you how much you should be willing to pay for additional units of a resource.  Going back to the Friday constraint, if we use the shadow price interpretation of the dual price then we can also say that we should be willing to pay up to $100 to have an additional staff member present on Friday.  If temporary employees are available for less than $100 per day, then we might want to consider this option.

As with reduced costs, dual prices are valid only over a limited range.  Range analysis will be discussed in more depth in a subsequent section.


LINDO Commands

In the Windows environment, LINDO partitions all commands into the following six categories:

•	File

•	Edit

•	Solve

•	Reports

•	Window

•	Help

These categories are simply the menus available to you when running LINDO.  To view a listing of the commands under a menu and a description of those commands click on the menu of interest.

Along with the description for each command, we also list any equivalent "button" from the toolbar and any equivalent accelerator keystroke combination.  The toolbar runs along the top of the main LINDO window and is illustrated in the following picture:

… click on any button to determine its function …

Each button on the toolbar corresponds to a menu command.  Not all menu commands have a toolbar button, but, in general, the most frequently used commands will have an equivalent button.

Along with accessing commands by mouse and buttons, most commands may also be accessed by a single, unique keystroke known as an accelerator.  The equivalent accelerator key is listed alongside each command in the menus.  As an example, the New command in the File menu may be accessed by pressing the F2 function key.


FILE MENU

Command	Description
New	Creates a new, blank model window
Open	Opens a model from a disk file
View	Opens a "View Only" model from disk
Save	Saves the active model window to disk
Save As	Saves a model window to disk and prompts for a new name
Close	Closes the active window
Print	Prints the contents of the active window
Print Setup	Used to configure your printer
Log Output	Opens or closes a log file used for recording the results of your session
Take Commands	Runs a LINDO script file
Basis Read	Loads a solution from disk into the active model
Basis Save	Saves the active model's current solution to disk
Title	Displays the title of the active model
Date	Displays the date
Elapsed Time	Displays the time that has elapsed since the start of the session
Exit	Exits LINDO


EDIT MENU

Command	Description
Undo	Undoes last edit operation
Cut	Removes selected text from window and places it in clipboard
Copy	Copies selected text to clipboard
Paste	Pastes clipboard's contents into active window
Clear	Removes selected text from window
Find/Replace	Finds a given string of text in active window and, optionally allows for replacement
Options	Used to configure LINDO options
Go to Line	Jumps to a given line number in active window
Paste Symbol	An editing tool that allows you to paste variable names and reserved symbols into active window
Select All	Selects all the text in the active window
Clear All	Clears all the text in the active window
Choose New Font	Resets font in active window


SOLVE MENU

Command	Description
Solve	Solves model in active window
Compile Model	Compiles model in active window
Debug	Debugs model in active window if it is infeasible or unbounded
Pivot	Performs a simplex iteration, or pivot, on the model in the active window
Preemptive Goal	Uses Lexico optimization (a form of goal programming) on active window


REPORTS MENU

Command	Description
Solution	Creates a solution report for active model window
Range	Creates a range (sensitivity) analysis report for active model window
Parametrics	Performs parametric analysis on the right-hand side of a constraint
Statistics	Displays statistics for the model in the active window
Peruse	Used to generate text reports on and/or graphics of selected items of the active model
Picture	Creates a text and/or graphics "picture" of the nonzero structure of the current model
Basis Picture	Creates a text based "picture" of the basis matrix for active model
Tableau	Displays the simplex tableau for the active model
Formulation	Displays the active model
Show Column	Displays a column/variable of the active model
Positive Definite	Determines if the constraint matrix of a quadratic programming model is positive definite


WINDOW MENU

Command	Description
Open Command Window	Opens a window that accepts traditional LINDO command-line commands
Open Status Window	Opens the solver Status Window which may be used to monitor the progress of the solver
Send To Back	Sends active window to the back, bringing windows to the front that were previously in the back
Cascade	Rearranges positions of all open windows in an overlapping "cascade" style
Tile	Rearranges positions all open windows in a "tiled" style
Close All	Closes all open windows
Arrange Icons	If any windows are minimized, the icons for the minimized windows will be arranged at the bottom of the screen


HELP MENU

Command	Description
Contents	Display a table of contents of the LINDO Help system
Search for Help On	Performs a search of the Help system for a user specified topic
How to Use Help	Gives some help on using the Help system
About LINDO	Displays specific information about your version of LINDO including the version number and maximum problem capacity

All LINDO menu commands available under Windows are listed and explained below.  The commands are broken down into the six categories: File, Edit, Solve, Reports, Window, and Help.  These categories correspond to the six main menus in LINDO.


New Command
New Command	Accelerator: F2	Button:

The New command opens a new, blank model window.  You may enter a model directly into this window, or paste in text from the clipboard.


Open Command
Open Command	Accelerator: F3	Button:

The Open command reads a saved model file from disk and places it in an Edit Window.  All of the standard editing features (e.g., cut, copy and paste) are available in an Edit Window.  The one restriction is that Edit Windows are limited to handling files with up to 64,000 characters.  If you try to open a file that is too large for an Edit Window to handle, you will be prompted to place the file in a View Window instead (more on these when we get to the View command). Press here for a comparison of Edit Windows vs. View Windows.

When you issue the Open command, you will be presented with the Windows standard File Open dialog box as follows:

This dialog box has all the standard features for navigating your system in search of a file.  The only non-standard feature of the File Open dialog box is the list box in the lower left corner labeled "List files of type".  This allows the user to select one of the following four filters used for selecting files:  LINDO Text (*.ltx), LINDO Packed (*.lpk), MPS (*.mps), and All Files (*.*).  The first three filters correspond to the three different file formats supported by LINDO for storing models.  In most cases, we recommend that you use the LINDO Text (*.ltx) format.  This saves your model in text form exactly as it appears on your screen.

After selecting a file to open, LINDO examines the file to determine the format it was saved under.  If the model is in LINDO Text format, or some unknown format, it is read directly into LINDO without modification.  MPS format and LINDO Packed format files are converted to their LINDO Text equation equivalents before being displayed in a window.  For example, readers familiar with the MPS file format will find that if they were to read the following MPS file into LINDO:

NAME

ROWS

  N 1

  L 2

  L 3

  L 4

COLUMNS

    X         1           20.0000000

    X         2            1.0000000

    X         4            1.0000000

    Y         1           30.0000000

    Y         3            1.0000000

    Y         4            2.0000000

RHS

    RHS       2           50.0000000

    RHS       3           60.0000000

    RHS       4          120.0000000

ENDATA

LINDO converts the model into the more readable LINDO Text format before displaying it as follows:

LINDO keeps track of a file's original format.  Thus, when you save the model, LINDO uses the original format unless you specify otherwise.  Please refer to the Save command for more information.


View Command
View Command	Accelerator: F4	Button:

The View command reads a saved model file from disk and places it in a View Window.  Unlike the Open command which uses Edit Windows that are limited to files of 64,000 characters or less, the View command can read a file of any size and is limited only by available memory.  Press here for a comparison of Edit Windows vs. View Windows.

A View Window is primarily useful in viewing models and submitting them to LINDO's solver.  Although you can read large models into a View Window, you will not have all the editing capabilities of an Edit Window.  You can scroll through a View Window, use the Go To command to jump to a particular line, and use the Find/Replace command to search for a selected string and, optionally, replace the string.  If you need to do extensive editing on a large model, we suggest that you use an external editor (e.g., Word) to make your changes, and then load the file into LINDO with the View command.  If you use an external editor, be sure to have the external editor save the model as "Text Only", otherwise LINDO will not be able to read the file.

With the exception of using a View Window, the View command functions exactly as the Open command does.  Please refer to the Open command for additional insight into the functioning of the View command.


Save Command
Save Command	Accelerator: F5   Button:

Save As Command	Accelerator: F6

The Save and Save As commands save the contents of the active window to a disk file.  Save uses the model's existing file name, while Save As prompts you for a name to save under.  When issuing the Save As command, you will see the following, standard File Save As dialog box:

This dialog box has all the standard features that allow you to navigate through your system to save a file.  The one nonstandard feature is the list box in the lower left corner titled, "File Format".  When saving a model, you have a choice of three different formats.  The File Format list box is used to select the desired format.  The available formats are summarized in the table below:

Format	Ext	Description
LINDO Text	*.ltx	Window is saved in text format exactly as it appears on the screen.  Available for Model, Reports, and Command windows.  Comments and special formatting are not lost.
LINDO Packed	*.lpk	Model is saved in a proprietary, compressed format.  The file is a text file and may be easily ported to other platforms, but the contents are unreadable by the human eye.  Available only for Model windows.  All comments and special formatting are stripped from the model before saving.
MPS	*.mps	Industry standard MPS format.  This is an inefficient format in terms of required disk space, and is difficult to interpret.  The advantage of this format is that it is a widely accepted standard, and is portable to many other solvers.  Available only for model windows. All comments and special formatting are stripped from the model before saving.
Note that the Reports Window and Command Window may only be saved in the *.ltx text format.  Model Windows may be saved in any of the three formats.

The LINDO Packed and MPS formats do not support comments or special formatting (e.g., indenting and spacing), so be forewarned that, should you save a model in either of these formats, all comments will be stripped and LINDO will reformat the model.  For these reasons, we recommend that you always try to save your models using the LINDO Text format.  In addition, when *.lpk and *.mps files are read back in to LINDO, they are automatically translated into *.ltx format before being displayed on the screen.  Using *.ltx files will avoid this additional translation step.

When saving with the Save command, LINDO automatically uses the file's previous format.  You must use the Save As command if you wish to override a file's format


Close Command
Close Command	Accelerator: F7

The Close command closes the active window.  If you have made changes to the contents of this window without saving, you will be prompted to perform a save before the window closes.


Print Command
Print Command	Accelerator: F7	Button:

The Print command sends the contents of the active window to the printer.  You may print any type of window - Reports, Command, or Model.  If, for some reason,  the output from the printer is obscured or incorrect, you may need to configure your printer with the Printer Setup command.


Print Setup Command
Print Setup Command	Accelerator: F8

The Print Setup Command presents you with the standard Windows printer setup dialog box.  This allows you to control many options influencing how your document is printed.  The print facility in LINDO is fairly simple, so many of these options are not applicable.  In general, you should not need this command if you have already been successfully printing from your machine.


Log Output Command
Log Output Command	Accelerator: F9

The Log Output command prompts you for a file to send all subsequent Reports Window output to.  This is useful for creating disk copies of solution and range reports.  These log files may then be read into other applications or sent to your printer.

When selecting the Log Output command, you will be presented with the following dialog box:

This is a standard Windows file selection dialog box allowing you to select a particular file for logging output.  There are two additional features to note, however, in the lower right corner of the dialog box.  These features are the two check boxes labeled "Echo to screen" and "Append output".  The default is for both these boxes to be unchecked.

If you leave "Echo to screen" unchecked, output will be directed only to the log file, and not to the Reports Window.  Checking "Echo to screen" will cause output to be directed to both the log file and the Reports Window.  If you are directing a lengthy solution to disk using the Log Output command, the process can be sped up substantially by suppressing simultaneous output to the Reports Window.

If "Append output" is not checked, any preexisting log file under the selected name will be overwritten and lost.  LINDO will warn you if you are about to overwrite an existing log file.  If "Append output" is checked, LINDO will append output to the end of any preexisting log file.

The Log Output command works as a "toggle".  When you first select the command, you open a file for logging output.  As long as this file is open, a checkmark will appear next to the command in the File menu indicating that you are in Log Output mode.  Select the command again, and the log file is closed and the checkmark is removed from the menu.

As an example, suppose you wish to create a disk file containing a copy of the solution report for the active model.  First, solve the model using the Solve command in the Solve menu.  Next, select the Log Output command from the File menu to open the file for the solution report.  Once you have opened the file, pull down the File menu again and note the checkmark adjacent to the Log Output command indicating that you are now in "Log Output" mode.  You have now opened the log file, but, as yet, it contains no data.  To remedy this, select the Solution command from the Reports menu.  The solution will then be sent to the log file (note: the solution will not appear on your screen unless you also checked the "Echo to screen" checkbox in the Log Output dialog box).  Finally, close the log file by once again selecting the Log Output command.  You should now have a disk copy of the solution report suitable for such things as routing to the printer, pasting into a report, or loading into a text editor.

Press here for tips on Capturing Lengthy Sessions using the File|Log Output command.


Capturing Lengthy Sessions

As you are running LINDO, output messages and reports are all directed to the Reports Window.  Each new line of output is appended to the end of all other output in the Reports Window.  The Reports Window can only maintain up to about 64,000 characters of data.  Once it approaches this limit, LINDO deletes old output from the top of the Reports Window to make room for new output at the bottom.  This makes it impossible to maintain entire copies of lengthy sessions in the Reports Window.  If you would like to save a copy of an entire session that will exceed the 64,000 character limit, simply open a log file before beginning your work using the File|Log Output command and check the "Echo to screen" checkbox in the Log Output dialog box.  All output to the Reports Window will also be directed, in duplicate, to the selected log file.  When you are finished running LINDO, a copy of the output for the entire session will be contained in the log file.


Take Commands Command
Take Commands Command	Accelerator: F11

LINDO for Windows supports a command language for building script, or macro, files.  The commands available are discussed in detail in chapter 3 of the documentation, LINDO for Command-line Environments.  If you build a script file, you may run it using the Take Commands command.

As an example, suppose we have a situation where we run a model using several values for a particular right-hand side coefficient, saving a solution after each modification to the right-hand side.  These operations would require us to input a number of commands.  If we needed to do this on an ongoing basis, inputting all the required commands would be tiresome and prone to error.  It would be better to build a script file that we can run by issuing a single Take Commands command.  Such a script file might look as follows:

BAT

! A 3 warehouse, 4 customer transportation model:

!

! XWH<i>C<j> = amount shipped from 15 warehouse <i>

! to customer <j>

MIN     6 XWH1C1 + 2 XWH1C2 + 6 XWH1C3 + 7 XWH1C4

      +  4 XWH2C1 + 9 XWH2C2 + 5 XWH2C3 + 3 XWH2C4

      +  8 XWH3C1 + 8 XWH3C2 +   XWH3C3 + 5 XWH3C4

 SUBJECT TO

! Demand constraints:

 C1)  XWH1C1 + XWH2C1 + XWH3C1 >=   10

 C2)  XWH1C2 + XWH2C2 + XWH3C2 >=   17

 C3)  XWH1C3 + XWH2C3 + XWH3C3 >=   22

 C4)  XWH1C4 + XWH2C4 + XWH3C4 >=   12

! Supply constraints:

 WH1)  XWH1C1 + XWH1C2 + XWH1C3 + XWH1C4 <=   30

 WH2)  XWH2C1 + XWH2C2 + XWH2C3 + XWH2C4 <=   25

 WH3)  XWH3C1 + XWH3C2 + XWH3C3 + XWH3C4 <=   21

END

! Solve the model

TERSE

GO

! Divert a solution

DIVERT SOLU.10

SOLU

RVRT

! Set RHS of C1 to 15, resolve and save report

ALT C1 RHS

15

TERS

GO

DIVERT SOLU.15

SOLU

RVRT

! Set RHS of C1 to 20, resolve and save report

ALT C1 RHS

20

TERS

GO

DIVERT SOLU.20

SOLU

RVRT

BAT

LEAVE

To have LINDO run the commands contained in  this file, simply run the Take Commands command and input the name of the file to the prompt.


Basis Save Command
Basis Save Command	Accelerator: Alt+F2

In the parlance of operations research, a solution to a linear programming model is referred to as a basis.  Thus, the Basis Save command is simply a command to save the solution to your model.  Why would you want to save a model's solution?  Suppose you need to run the model at a later date, perhaps with some minor modifications.  Starting from the old optimal solution could save you considerable time - especially if the model is large.

These saved solutions are different from the solution reports that LINDO generates with the Solution command.  In general, solutions saved with the Basis Save command are difficult, if not impossible, to interpret.  They are intended primarily for loading back into LINDO at some later date.

Assuming you have solved the active model, you may save the solution at any point by running the Basis Save command.  When you issue the Basis Save command you will be presented with a dialog box similar to the following:

This is the standard Windows dialog box for selection of a save file.  Once you have selected the file to save the basis in, you must also select a format.  LINDO offers the following three different basis formats:

•	Punch	MPS "Punch" format

•	FBS	"File Basis Save" format

•	SDBC	"Save DataBase Column" format

The details of these formats are of little interest.  Be aware, however, that your best results will be obtained with either the Punch or FBS formats.  (SDBC does not save all the details required of a true basis, but is supported for backward compatibility.)

Saving a basis for any model other than a linear programming model (e.g., integer and quadratic programs) is, generally, of little help.

For information on restoring a saved basis please refer to the Basis Read command.


Basis Read Command
Basis Read Command	Accelerator: F12

The Basis Read command is used to retrieve a solution to a model saved using the Basis Save command.  For more information on how and why you save a solution, refer to the Basis Save command.

To restore a solution using the Basis Read command, you must first select the model window you wish to associate the solution with by clicking on it with the mouse.  This model then becomes the active model.  Once a model window is activated, the Basis Read command should be available in the File menu.  When you choose the Basis Read command, LINDO will compile the model if it hasn't been compiled already, then the following dialog box appears:

This is a standard Windows dialog box for selecting the basis file to read.  You can use the list box in the lower left corner to select a file filter based on the three basis file formats used by LINDO:

•	Punch	MPS "Punch" format

•	FBS	"File Basis Save" format

•	SDBC	"Save DataBase Column" format

Once you have selected the correct basis file, LINDO will attempt to install the solution into the model in the active window.  Typically, your next step will be to solve the model.  If the basis contained an optimal solution to the model, the required solution time should be quite short.  In fact, usually no iterations are required at all.  If you have modified the model slightly from the model used to save the solution, then LINDO may require several iterations to find the new optimum.  Regardless, this beats having to wait through conceivably thousands of iterations on a large model.

One final note:  As long as a model is open in LINDO, LINDO automatically keeps a basis in memory.  It is not until you physically close a model, or exit and reenter LINDO, that you need to read in a basis.  If for some reason you want to eliminate the basis in memory to force LINDO to start from "scratch" on a model, you can do this by issuing the Compile command in the Solve menu.  When you explicitly issue the compile command, LINDO discards all internal basis information.


Title Command
Title Command	Accelerator: Alt+F3

You may give a title to a model.  In the following example, we have dubbed the model "Product Mix Example":

Running the Title command will cause the model's title to be sent to the Reports Window, and you should see the following:

The Title command is useful for attaching headers to solution reports.  Otherwise, it is sometimes difficult to look at a solution and determine its corresponding model.


Date Command
Date Command	Accelerator: Alt+F4

The Date command sends the current date and time to the Reports Window.  This is useful for date stamping reports.  Sample output from the Date command appears below:


Elapsed Time Command
Elapsed Time Command	Accelerator: Alt+F5

The Elapsed Time command sends the elapsed runtime of your current session to the Reports Window.  This command is useful when you want to determine runtimes.  Sample output from the Elapsed Time command follows:

In this example, LINDO has been running for 17 minutes and 12.11 seconds.


Exit Command
Exit Command	Accelerator: Alt+F6

The Exit command causes LINDO to quit and returns you to the operating system.  You will be prompted to save any files that have modified since they were last saved.


 EDIT WINDOWS VS. VIEW WINDOWS

There are two commands contained in the File menu that open a model in LINDO.  These are the Open command and the View command.  When you read a model into LINDO using the Open command, the model is placed into an Edit Window.  When you read a model with the View command, the model is placed into a View Window.  You can determine when a model is in a View Window by checking the window's title bar.  If it is  a View Window, a "(v)" will appear after the file's name in the title bar.

The distinction between View Windows and Edit Windows is important when it comes to editing your files.  Edit Windows can only handle files with up to approximately 64,000 characters, while View Windows can handle files as large as available memory allows.  Edit Windows offer an advantage over View Windows in that there are many more editing features available.  Thus, many of the commands discussed in this section are only available in Edit Windows.  The table below lists the editing features supported by both classes of windows, and should help in understanding the differences between them.

Editing Feature	View Window	Edit Window
Capacity	Limited only by available memory	64K
Undo		x
Cut		x
Copy		x
Paste		x
Clear		x
Find/Replace	x	x
Go To Line	x	x
Paste Symbol		x
Select All		x
Clear All		x
Choose New Font	x	x
If you need extensive editing capabilities for a large model, we recommend that you use an external text editor to do your work.  The model must be saved as "Text Only" in the external editor.  Once this is done, the model may be read into LINDO using the View command.


Undo Command
Undo Command	Accelerator: Ctrl+Z

The Undo command is used to reverse the last action taken in an Edit Window.  The Undo command is not available in View Windows.  For a discussion on the distinction between Edit and View Windows, please click here.


Cut Command
Cut Command	Accelerator: Ctrl+X   Button:

The Cut command is used to remove selected text from an Edit Window.  The text that is removed is placed into the Windows clipboard, and may be pasted into other applications or other windows in LINDO.  To select text for cutting, simply press down on the left mouse button at the beginning of the text and then drag the mouse pointer to the end of the text and release the mouse button.  The selected text should now be displayed in reverse video (white letters, black background).  Selecting the Cut command at this point will cause the selected text to be removed from the window and placed into the Windows clipboard.


Copy Command
Copy Command	Accelerator: Ctrl+C   Button:

The Copy command copies selected text from an Edit Window into the system clipboard.  The text is not deleted from the Edit Window when it is copied.  Once there, it may be pasted into other applications or other Edit Windows in LINDO.  To select text for copying, simply press down on the left mouse button at the beginning of the text and then drag the mouse pointer to the end of the text and release the mouse button.  The selected text should now be displayed in reverse video (white letters, black background).  Selecting the Copy command at this point will cause the selected text to be inserted into the Windows clipboard.


Paste Command
Paste Command	Accelerator: Ctrl+V   Button:

The Paste command pastes text from the Windows clipboard into an Edit Window at the current cursor position.  If text has been selected, the Paste command will erase the selected text before installing the clipboard text.  You may only paste text into LINDO; graphics are not allowed.


Clear Command
Clear Command	Accelerator: Del

The Clear command is used to remove selected text from an Edit Window.  The text that is removed is not placed into the Windows clipboard.  To select text for clearing, simply press down on the left mouse button at the beginning of the text and then drag the mouse pointer to the end of the text and release the mouse button.  The selected text should now be displayed in reverse video (white letters, black background).  Selecting the Clear command at this point will cause the selected text to be removed from the window.


Find/Replace Command
Find/Replace Command	Accelerator: Ctrl+F   Button:

The Find/Replace command may be used in either an Edit or a View Window to find some specified string of text, and, optionally, replace it with an alternate text string.  After invoking the Find/Replace command you will be presented with the following dialog box:

If you just want to find a string of text, enter it in the box labeled "Find What" then press the "Find Next" button.  LINDO will begin the search from the current cursor position.  If you want to begin the search from the top of the file, you may want to use the Go To Line command to reposition the cursor to the top of the file before issuing the Find/Replace command.

If you want to replace the search string with an alternate string, enter the replacement text in the box labeled "Replace With", then press the Replace button.  The first time you press replace, LINDO will simply jump to the next occurrence of the search string.  Pressing replace again causes LINDO to replace the search string and then jump to the next occurrence.  Using this technique, you can pass through a window clicking Replace when you want to replace an occurrence or Find Next when you want to skip to the next occurrence without replacing the current selection.

To replace all occurrences of the search string from the current insertion point to the end of the document, press the Replace All button.  LINDO will inform you as to the total number of replacements that were performed.

The default action for LINDO when doing a Find/Replace is to ignore the case of the text.  If you want LINDO to match the case of the text exactly, click the Match Case checkbox in the lower left corner of the dialog box before proceeding with the command.


Options Command
Options Command	Accelerator: Alt+O   Button:

The Options command is used to modify default system parameters.  When issuing the Options command, the following dialog box will appear:

… click on any option field above to determine its function …

LINDO options remain in effect for the entire session.  If you modify any options and wish to preserve their setting from one LINDO session to the next, press the "Save" button.  This will save the current options so that they can be restored when LINDO is restarted.  If at anytime you wish to return to the default set of options, press the "Default" button.

Options in LINDO are broken down into the following categories:

1) Optimizer Options - options that pertain to the functioning of the solver engine and are broken down into the following two subgroups:

a) Integer Programming (IP) - options that influence the solvers approach on IP models

b) General - general solver options that pertain to all classes of models

2) Output Options - options that affect the amount and style of output from LINDO

The remainder of this section explores the options available in each of these categories


Optimizer Options

The group box labeled "Optimizer Options" contains all the options that influence the functioning of the optimizer.  This group box consists of the two subgroup boxes: "Integer Programming" and "General".  The Integer Programming group of options influence how LINDO's branch-and-bound solver handles integer programming models.  The General group of optimizer options pertain to the way in which the solver handles all classes of models - linear, integer and quadratic.


INTEGER PROGRAMMING OPTIMIZER OPTIONS

Given that integer programming problems can, at times, be extremely difficult to solve, the following IP options will be of interest if you plan on solving anything other than the most trivial IP models.  The integer programming options included in LINDO and discussed below are:

•	Preprocessing

•	Preferred branching direction

•	IP optimality tolerance

•	IP objective hurdle

•	IP variable fixing tolerance

Much of the discussion of these parameters assumes a certain amount of knowledge about the branch-and-bound solution algorithm for IP models.  If you are unfamiliar with this algorithm and would like to learn more, you can refer to the companion LINDO textbook, Optimization Modeling with LINDO.


Preprocess

An optional phase to the integer programming solver in LINDO is known as preprocessing.  During the preprocessing phase, the solver does extensive evaluation of your model in order to add IP cuts.  IP cuts are simply constraints that "cut" away sections of the feasible region to the continuous model (i.e., the model with integrality conditions dropped) that are not contained in the feasible region to the integer model.  On most IP models, this will accomplish two things.  First, solutions to the continuous problem will tend to be more naturally integer.  Thus, the branch-and-bound solver will have to branch on fewer variables.  Secondly, the bounds that come out of solutions at intermediate nodes will tend to be "tighter", allowing the branch-and-bound solver to "fathom" (i.e., drop from consideration) branches sooner.  These improvements can really turbocharge the IP solver on many a model.

There is a downside to IP preprocessing that you should be aware of, however.  As you can imagine, determining a valid and meaningful set of cuts can be time consuming.  If your model is naturally tight or if there are just a few integer variables, then the time to generate cuts can exceed the savings in solution times resulting from those cuts.  In these cases, you are better off skipping the preprocessing phase.

LINDO defaults to performing the preprocessing step.


Preferred Branch

When LINDO is solving an IP one of the fundamental operations of the solver is branching.  Initially, the solver lets the integer variables be continuous.  The solver searches the integer variables to determine if any have fractional values.  If they do, then the solver will branch on these variables.  When the solver branches on a variable it fixes its value to one of the nearest integer values, and continues.  Since there are always two close integer values to any fractional number (one just greater than and one just less than the fractional number), LINDO can initially branch either up or down.  With some models, always branching up first or down first can make a large difference in performance.  The Preferred Branch option gives you control over this parameter.

The default is for LINDO to pick the branching direction.  In this case, LINDO will make an educated guess at whether branching up or down looks most favorable for a given variable.


IP Optimality Tolerance

The IP Optimality Tolerance command specifies a fraction f which indicates to the solver that it should only search for solutions with objective values that are 100*f% better than the best one considered so far.  For command line users of LINDO, the IP Optimality Tolerance corresponds to the IPTOL value.

The end results of using an IP Optimality Tolerance are twofold.  First, on the positive side, solution times will tend to be considerably faster.  On the negative side, use of this tolerance can mean that LINDO will not find the optimal solution, and you will not receive any warning to this effect in the solution report.  You will know, however, that the solution found is within f% of the true optimal.  On large integer models, the alternatives of getting a solution within say 2% of optimal in a few minutes versus getting the true optimal in a few days, makes the use of an IP Optimality Tolerance value quite attractive.

As an illustration of the potential power of the IP Optimality Tolerance, consider the following small IP:

The default in LINDO is to use no IP Optimality Tolerance.  When we stick with this default we find the following in the Solver Status window once optimization is complete:

Note that it has taken us 10,064 iterations and 1,715 branches to reach optimality.  Now, we set the IP Optimality Tolerance to .01 in the Options Dialog Box as follows:

By setting this value to .01 we are telling the solver that we are happy with any integer solution that is no more than 1% worse than the true optimal solution.  Re-solving the same model yields the following statistics in the Solver Status window:

This time, the model solves in only 74 iterations and 7 branches!  The true objective value of 8,929,390 is a mere 0.002% better than the objective of 8,929,170 found using an IPTOL value.  Differences of this magnitude applied to a large IP model can make for dramatic improvements in runtimes.

The default IP Optimality Tolerance value is "None", in other words, the feature is disabled.


IP Objective Hurdle

The IP Objective Hurdle is used to specify a bound on the worst objective value of an integer program. This bound is usually based on a known feasible solution. The bound is used in the branch-and-bound algorithm to narrow the search for the optimum.  When LINDO is searching for a initial integer solution, it can ignore branches with objective values worse than your hurdle value, because LINDO knows that a better solution (the hurdle) will be found on a subsequent branch.  In other words, branches must have objective values more attractive than the hurdle value before they will be considered.  Depending on the problem, a good hurdle value can reduce solution times.

As an example, consider the following, small IP:

Running without an IP hurdle, we obtain the following results with the solver

Now, suppose we know that a feasible integer solution exists with an objective value 14.  If we set the IP hurdle to this value in the Options Dialog box as follows:

and then resolve, we get the following results:

Notice that the total number of iterations fell by more than 50 percent, from 68 to 32.  Reductions of this magnitude can be a big help when tackling large IP models.

The default IP Objective Hurdle value is "None", in other words, the feature is disabled.


IP Variable Fixing Tolerance

LINDO begins solving IP models by solving a linear relaxation of the original IP model.  This linear relaxation merely lifts the integrality requirements, and solves the remaining model as a pure linear programming problem.  You may, optionally, have LINDO examine the solution to the linear relaxation to find integer variables that are integer valued with high reduced costs.  LINDO will initially fix these variables to the integer values obtained in the relaxation, and optimize over a restricted branch-and-bound tree.  The underlying logic in doing this is that integer valued variables with a high reduced cost would incur a large expense if they were to move away from their bounds.  Given this, they have a relatively high probability of remaining at their current values in the optimal integer solution.  By initially fixing these variables, and solving the restricted tree, the hope is to obtain good objective bounds early on allowing large portions of the full tree to be fathomed once we free up the fixed integer variables.  To exploit this feature, input a numeric value in the IP Variable Fixing Tolerance box in the Options window.  When solving IPs, LINDO will initially fix all integer variables with reduced costs exceeding this value.

The default IP Variable Fixing Tolerance value is "None", in other words, the feature is disabled.


GENERAL OPTIMIZER OPTIONS

Options included here influence the optimizer's operation on all classes of models, and include the following:

•	Nonzero Limit

•	Iteration Limit

•	Initial Constraint Tolerance

•	Final Constraint Tolerance

•	Entering Variable Tolerance

•	Pivot Size Tolerance


Nonzero Limit

When we speak of nonzeros, we are referring to the coefficients on the variables in the constraint equations.  It would be unusual for all variables in a model to appear in a single constraint.  In fact, in most large, real world models less than one percent of the variables will appear in the average row.  Thus, in any given row, most variables have a coefficient of zero.  Storing all these zeros would be wasteful with respect to both performance and storage.  Therefore, LINDO only stores the nonzero, coefficient values.

When LINDO starts, it sets aside a fixed amount of space for the nonzero coefficients.  You can determine this limit by examining the Nonzero Limit field in the Options dialog box.   If you have a model with a particularly large amount of nonzeros, you may want to increase the Nonzero Limit to allow LINDO to optimize the model.  On the other hand, if you are trying to conserve memory, you might want to decrease the Nonzero Limit.  Each nonzero you allocate requires eight bytes of storage.  This memory will be taken up regardless of how large or small your models are.

To change the nonzero limit, enter a new value in the Nonzero Limit field then press the "Save" button.  At this point, you will be presented with the message:

LINDO cannot physically change the Nonzero Limit in midstream.  In order to accomplish this, you will need to exit LINDO and restart.  Upon restarting, the new nonzero limit will be established.  You can verify the true, physical Nonzero Limit at any time by selecting the About command from the Help menu.  This command displays the LINDO release number, copyright information, and, at the bottom, you should find a box similar to the following:

This box lists the constraint and variable limits of your copy of LINDO along with the physical nonzero limit.

We should also mention that LINDO uses the nonzero allocation as a work area during optimization.  Specifically, LINDO stores the basis inverse matrix along with the structural nonzeros in this shared memory location.  Given this, you should try to allocate a good number of additional nonzeros over and above what is required by just the structural nonzeros.  If LINDO runs out of nonzero space, it halts the optimization and returns with an error.


Iteration Limit

The LINDO solver uses the simplex method to perform optimization.  The simplex method performs a series of iterations (also called pivots) until an optimal solution is found.  At each iteration, a "favorable" variable is introduced into the solution, while another variable is simultaneously driven to zero and dropped from the current solution.

In some cases, you may want to place an upper limit on the number of iterations that LINDO performs.  You can do this by typing a limit value into the box labeled "Iteration Limit" in the Options dialog box as follows:

Should LINDO hit the Iteration Limit before optimization is complete, you will be presented with the following dialog box:

If you want to halt optimization, press the button labeled "Cancel".  LINDO will end optimization, and return with the best answer found so far.

If you change your mind and you want to continue with optimization, input a number corresponding to the additional number of pivots you want LINDO to perform and then press "OK".  The optimizer will resume and, should it hit the new limit before completion, will prompt again for an additional increment to the Iteration Limit.

The default Iteration Limit is "None", in other words, the number of iterations is not limited.


Initial Constraint Tolerance

Final Constraint Tolerance

Due to the finite precision available for floating point operations on digital computers, LINDO can't always satisfy each constraint exactly.  Given this, LINDO has two internal tolerances that dictate the maximum amount of violation allowed on a constraint in order to still consider it "satisfied".  These tolerances are called the Initial Constraint Tolerance and the Final Constraint Tolerance.  The Initial Constraint Tolerance is used when the solver first begins, and can be relatively loose in order to speed solution times.  Once LINDO has closed in on an optimal solution, it switches to the Final Constraint Tolerance, which should be relatively tight in order to guarantee an accurate final solution.  The default value for the Initial constraint tolerance is .8-5, while the default for the Final Constraint Tolerance is .1-5.

One instance where these tolerances can be of use is when you have a model that is returning infeasible from the solver.  When a model is infeasible, LINDO reports a sum of infeasibilities, which is the amount of violation on all the constraints and bounds.  If this number is relatively small, then you might want to consider loosening the constraint tolerances.  This is particularly true in a model where scaling is poor and the units of measurement on some constraints are such that minor violations are insignificant.  For instance, suppose you have a budget constraint measured in millions of dollars.  In this case, a violation of a few pennies would be of no consequence.  Short of the preferred method of rescaling your model, loosening tolerances may be the most expedient way around a problem of this nature.


Entering Variable Tolerance

The fundamental operation in the algorithm used by the LINDO solver involves introducing a variable that formerly had a value of zero into the solution while, simultaneously, driving another variable to zero.  Variables are only introduced into the solution if they are favorable to the progress of objective.  Due to roundoff error in floating point calculations, a variable may compute as being favorable when, in fact, it may have no impact or, worse, a negative impact on the objective.  The Entering Variable Tolerance is the dividing line between what we consider favorable and unfavorable.  Variables with negative reduced costs whose absolute values exceed the Entering Variable Tolerance will be considered as potential candidates for entering into the solution.  The default value for the Entering Variable Tolerance is .7-5.


Pivot Size Tolerance

When LINDO introduces a variable into the solution, it must assign the variable to a constraint, or row.  Each row has one variable assigned to it, and this assigned row is used in computing the value of the variable.  The row in which a variable is assigned is called its pivot row.  In order for LINDO to assign a variable to a row, there must currently be a nonzero in that row, which is called the pivot element.  The exact value of the pivot element will vary depending on all the matrix operations that were performed prior to assigning a variable to the row.  If the pivot element is very small, then, given the finite precision of floating point arithmetic,  there is a chance that the pivot element is merely a phantom consisting of noise due to roundoff error.  Assigning a variable to such a row can lead to erratic behavior of the solver.  The Pivot Size Tolerance is the dividing line between what is, and what is not, considered a valid pivot element.


OUTPUT OPTIONS

Output options allow you to control the amount and type of output you receive from LINDO.  The options included under this category are:

•	Status Window

•	Terse Output

•	Page Length Limit

•	Terminal Width


Status Window

Whenever LINDO begins solving a model it displays a Solver Status Window that allows you to monitor the progress of the solution process.  If you want to keep this window from popping up every time you solve a model, remove the checkmark from the Status Window checkbox in the Options dialog box as illustrated here:

Once you have done this, LINDO will no longer automatically display the Solver Status Window.  However, you can still bring it up at any time during optimization by issuing the Open Status Window command from the Window menu.

LINDO defaults to displaying the Solver Status Window whenever the Solver is invoked.

Please refer to the Solve command for additional information on the Solver Status Window.


Terse Output

LINDO automatically routes a solution report to the Reports Window after solving a model.  You can suppress this by checking the Terse Output checkbox in the Options dialog box as shown here:

Note that you can always request a solution report at any time using the Reports|Solution command.

Switching to Terse Output will also suppress much of the trace output sent to the Reports Window when solving an integer programming model.

The default in LINDO is to not run in Terse Output mode.


Page Length Limit

You can enter a Page Length Limit to request that LINDO interrupt output to the Reports Window every few lines and wait for a response from you.  This is useful if you want to examine the solution as it is printed, before it has a chance to scroll out of the Reports Window.  For instance, if you enter a page length limit of 25 as shown here,

then every time LINDO sends 25 lines of output to the Reports Window it will stop and display this dialog box:

LINDO will not resume output until you press the "More" button in this box.

The default Page Length Limit is "None", in other words, this feature is disabled.


Terminal Width

When doing sequential I/O operations, LINDO respects a Terminal Width (i.e., maximum characters allowed per line).  Thus, output lines to the Reports Window are wrapped to fit within the Terminal Width and input records are truncated to fit.  You may change the Terminal Width in the Options dialog box in the following edit box:

The minimum and maximum Terminal Width values allowed are 40 and 132.  The default Terminal Width is 80 characters.


Go To Line Command
Go To Line Command	Accelerator: Ctrl+T   Button:

The Go To Line command allows you to jump to a specified line in the current window.  You may also select to jump to either the top or the bottom of the window.

When issuing the Go To Line command, you will be presented with the following dialog box:

If you want to go to a specific line, enter the line number in the edit box labeled "Line number to go to" and click the OK button.  LINDO will move the cursor to the start of the specified line, scrolling it into view if required

To go to the top or the bottom of the window, click either "Go to Top" or "Go to End".


Paste Symbol Command
Paste Symbol Command	Accelerator: Ctrl+P   Button:

The Paste Symbol command posts a dialog box that assists you in building a model.  This dialog box contains all the reserved symbols in the LINDO syntax, plus all the variable and row names defined so far in the model.  The dialog box appears as follows:

When you double-click on a symbol, it is appended to the edit box titled "Paste Buffer".  Once you have finished constructing the constraint, you press the Paste button to send the contents of the paste buffer into the current model window at the cursor point.  You may also type directly into the paste buffer if desired.  Press the Clear button to erase the contents of the paste buffer.

As an example, suppose we wanted to use the above dialog box to add the constraint XSAT + XSUN >= 4 to our model.  We would double-click on the items:

1.	XSAT in the Variables list box

2.	The plus sign in the Reserved list box

3.	XSUN in the Variables list box

4.	The >= sign in the Reserved list box

Finally, we would enter the right-hand side of 4 directly into the paste buffer.  At this point, the dialog box should resemble the following:

Note that the paste buffer contains the desired constraint.  At this point, we may insert it into the model window at the current cursor location by pressing the Paste button.

One final, important concept to keep in mind when using the Paste Symbol command is that LINDO must be able to compile (see the Compile command) the current model in order to build the variable and row name lists.  If LINDO can't compile the model, the Paste Symbol command will not execute.


Select All Command
Select All Command	Accelerator: Ctrl+A

The Select All command sets the current selection to be all the text in the current window.  This is useful when you want to copy the entire contents of a window and place it into a new window or into a different application.


Clear All Command

The Clear All command erases the entire contents of the current window.  This is useful when you want to clear old output from the Reports Window, and start with a "clean slate".  If you mistakenly run the Clear All command, it may be reversed by the Undo command.


Choose New Font Command

The Choose New Font command allows you to select a new font in which to display and print the current window.  You may find it easier to read models and reports if you select a monospace font such as Courier


Solve Command
Solve Command	Accelerator: Ctrl+P   Button:

The Solve command is the primary command that you will use from the Solve menu.  This command causes LINDO to begin solving your model.  If it is a relatively small model, the Solve command will execute almost instantaneously.  If it is a large, tough model, the Solve command could literally run for days (assuming you have the patience to wait that long).

When you invoke the Solve command, LINDO will check to see if the model has been modified and needs to be compiled.  Assuming no compilation errors exist, LINDO posts a window called LINDO Solver Status.  This window allows you to monitor the progress of the solver towards a solution.  A sample of the window appears below:

A description of the various fields and controls within the Status Window appears in the table below.

Field/Control	Description
Status	Gives status of current solution.  Possible values include: Optimal, Feasible, Infeasible, Unbounded.
Iterations	Number of solver iterations.
Infeasibility	Amount by which constraints are violated.
Objective	Current value of the objective function.
Best IP	Objective value of best integer solution found.  Only relevant in integer programming (IP) models.
IP Bound	Theoretical bound on the objective for IP models.
Branches	The number of integer variables "branched" on by LINDO's IP solver.
Elapsed Time	Elapsed time since the solver was invoked.
Update Interval	The frequency (in seconds) that the Status Window is updated.  You can set this to any nonnegative value desired.  Setting the interval to zero will tend to increase solution times.
Interrupt Solver	Press this button to interrupt the solver at any point and have it return the current best solution found.
Close	Press this button close the Status Window. Optimization will continue.  The Status Window may be reopened by selecting the Status Window command from the Window menu.
When the Solve command is finished, the solution will be sent to the Reports Window, where it can be reviewed, edited, and printed.  Hopefully, the Status Window will indicate that you have an optimal solution.  If the Status Window claims that the solution is infeasible or unbounded, then there is a problem in your formulation, and you should not attempt to use the results from LINDO.  If the model contains no integer variables and is not a quadratic programming model, the LINDO Debug command can assist you in finding the flaws in your model when it is either unbounded or infeasible.

If you want to suppress the automatic generation of a solution report at the end of the solve command, click on "Terse output" in the Edit|Options command dialog box.

The Reports Window can hold up to 64,000 characters of information.  If required, LINDO will erase output from the top of the Reports Window in order to make room for new output at the bottom of the window.  If you have a lengthy solution report that you need to examine in its entirety, you can log all information sent to the Report Window in a disk file using the Log Output command from the LINDO File menu.  This file can then be examined using an external text editor or using the View command from the LINDO File menu.

If the model is linear, then, after writing the solution report, LINDO will prompt you to determine if you wish to do sensitivity and range analysis.  If you request to see this report, it will also be sent to the Reports Window.  You can also request this report at any time by using the Reports|Range command.


Compile Model Command
Compile Model Command	Accelerator: Ctrl+E   Button:

Before LINDO can solve your model, it must compile (i.e. translate) the model into the arithmetic form required by the LINDO solver.  LINDO will automatically do this if required, but you may request a compile at any time by running the Compile Model Command.

While compiling your model LINDO maintains the following window to keep you posted on the progress of the compilation:

This window displays a progress bar showing the percentage of work completed along with a running count of constraints, variables, and nonzero coefficients encountered so far in the model.

If LINDO finds a syntax error during compilation, it will inform you of the line number where the error occurred and move the cursor to that line.

Requesting a compile may be useful in several instances.  First off, you can use the compile command to check the syntax of a model as you are developing it.  Secondly, compiling a model builds the variable and row name tables required by the Paste Symbol command.  Finally, running the compile command eliminates any stored basis for the model.  If you have solved the model during the current session, LINDO maintains a basis (i.e. solution) in memory to use as a starting point should you modify and resolve it again.  Issuing the compile command causes LINDO to erase the basis for the model.  Thus, all subsequent Solve commands will commence from "scratch".


Debug Command
Debug Command	Accelerator: Ctrl+D

In the ideal world, all models solved by LINDO would return an optimal solution.  Unfortunately, this is not the case.  Sooner or later, you are bound to run across either an infeasible or unbounded model.  This is particularly true in the development phase of a project when the model will tend to suffer from typographical errors.  Tracking down an error in a large model can prove to be a daunting task.  The Debug command is useful in narrowing the search for problems in both infeasible and unbounded models.

When Debug encounters a model with no feasible solution it first tries to identify one or more "crucial" constraints.  A constraint is crucial if dropping just that constraint from the entire model is sufficient to make the model feasible. These constraints are identified by Debug as the SUFFICIENT SET(ROWS).  Not every infeasible model has a crucial constraint.  Regardless of whether any crucial constraints were found, the Debug command also identifies a set of constraints as well as column bounds that constitute a NECESSARY SET(ROWS).  Such a set has the feature that it is infeasible; however, if any member of this set is deleted then the set becomes feasible.  Thus, it is necessary to make at least one correction in the NECESSARY SET(ROWS) if the model is to be feasible.

When Debug encounters an unbounded model it first tries to identify one or more "crucial" variables.  These variables are identified by Debug as SUFFICIENT SET(COLS).  A variable is crucial if fixing it is sufficient to make the model bounded.  Regardless of whether any crucial variables were found, Debug also identifies a set of variables that constitutes a NECESSARY SET(COLS).  Such a set has the feature that it is unbounded, but if any variable in this set is fixed, the set becomes bounded.

In summary, if the complete model would be feasible except for a bug in a single row, that row will be listed in the SUFFICIENT SET of rows.  The NECESSARY SET of rows is a set such that if as long as all of them are present, the model remains infeasible.

Typically, Debug helps substantially reduce the search effort.  The first version of Debug was implemented in response to a user who had an infeasible model.  The user had spent a day searching for a bug in a model with 400 rows.  Debug quickly found a NECESSARY SET with 55 constraints as well as one SUFFICIENT SET constraint.  The user quickly noticed that the RHS of the SUFFICIENT SET constraint was incorrect.

The following example illustrates.  The coefficient .55 in row 4 should have been 5.5.

When we attempt to solve this formulation we get the following error code:

Now, if we run the Debug command we are presented with the following report in the Reports Window:

The Debug command has correctly identified that the erroneous constraint number 4, when eliminated, is sufficient to guarantee a feasible solution.  Thus, Debug can be very useful in tracking down potential problems in a model.

In general, the kind of correction required in a constraint is one or more of the following: change the RHS, change the direction, change the coefficient of a variable in the constraint, or change the upper or lower bound of a variable in the constraint.

Debug operates in a similar manner for unbounded models.  In the following example, we introduced an error by placing a minus sign instead of a plus sign in front of variable Z3 in constraint 3.  A look at row 3 reveals that Z3 can be increased indefinitely, leading to an unbounded objective.

The resulting model is unbounded, and, when issuing the Solve command, we receive the unbounded error message:

Taking the cue from the error message and issuing the Debug command from the Solve menu we receive the following breakdown:

The Debug command has successfully determined that bounding Z3 is sufficient to bound the entire model.  This illustrates that Debug can be very useful for narrowing down the search for problems in an unbounded model.

In general, the kind of correction required in a column is one or more of the following: change the objective coefficient, change a coefficient in some constraint, change the direction of some constraint in which the variable appears, make either the upper or lower bound finite.


Pivot Command
Pivot Command	Accelerator: Ctrl+N

The fundamental operation in the simplex algorithm used by the LINDO solver involves introducing a variable that formerly had a value of zero into the solution while, simultaneously, driving another variable to zero.  This operation is referred to as a pivot.  The Pivot command allows you to perform individual pivots, optionally specifying the variable and constraint to perform the pivot on.

The Pivot command is not of much practical use, but it is of great potential interest to students of the simplex algorithm, particularly when coupled with the Tableau command.  The Tableau command can be used to view the current simplex tableau to assist in selecting an attractive pivot variable and it's pivot row.

User unfamiliar with the simplex algorithm can refer to any introductory operations research text to learn more.

As an example of the use of the Pivot command, consider the following model:

We will use the Pivot command twice to introduce both X and Y into the solution, and, in so doing, obtain the optimal solution.  When we first issue the Pivot command, we are presented with the following dialog box:

If you were to click the OK button at this point, LINDO would select the variable and the pivot row.  In most cases, as a minimum, you will want to select the pivot variable.  If you select the pivot variable, then you will also have the option of selecting the pivot row.  Be careful when selecting your pivot row.  LINDO will report that the objective function is unbounded if the row specified does not bound the pivot variable.  If you do not select a row, LINDO will select the correct one for you.

Getting back to our example, let's pivot on Y first since it has the highest objective coefficient.  Since we want to select the pivot variable, we must click on the button marked "Use Mine" in the box labeled "Variable Selection".  Next, we type the variable name, Y, into the edit box labeled "My Variable Selection".  Because we are also specifying the pivot row, we click on the button marked "Use Mine" in the box labeled "Row Selection".  Finally, we type the pivot row name into the box labeled "My Row Selection".  Examining our model we find that row 4 is the row that places the tightest restriction on Y, so we make row 4 our pivot row.  The Pivot command dialog box will now resemble the following:

At this point, data input is finished for our first pivot, so we press the OK button.  LINDO then performs the pivot operation and returns with a summary of the results in the Reports Window:

LINDO confirms that it has pivoted on Y in row 4 and that Y now has a value of 60 and the objective row has a value of 1800.

It is instructional to view the simplex tableau before performing the next pivot.  To display the tableau, select the Reports|Tableau command.  LINDO should display the following:

The reader experienced with the theory of the simplex algorithm can see that the only attractive variable to pivot on is X, due to it's negative reduced cost in row 1.  Furthermore, the row binding X will be row 2.  Thus, this must be our pivot row.  Entering all this into the Pivot command dialog box, we have the following:

Clicking OK to perform the pivot, results in this summary from LINDO:

After X enters the solution, the objective value climbs to 2050, which is the optimal solution.  If you would like a full solution report, select the Reports|Solution command.  You should receive the following:


Preemptive Goal Command
Preemptive Goal Command	Accelerator: Ctrl+G

The Preemptive Goal command performs Lexico-optimization on a model.  This allows the user to specify an ordered list of objectives.  LINDO begins by optimizing the first objective.  Given the optimal value for the first objective, it then optimizes the second objective subject to the first objective being equal to its optimal value.  Given the optimal values for the first and second objectives, it then optimizes the third objective, etc.

A typical situation has a first objective of minimizing cost or maximizing profit and a second objective of "smoothing" the solution in some sense.  Examples are cutting stock or staff scheduling applications where a number of demand requirements must be satisfied.  Traditional formulations of such problems frequently have "multiple optima" solutions, some of which greatly over-satisfy one or two requirements and just barely satisfy all others.  The user typically has a slight preference for solutions that "spread out" the over-satisfaction more evenly.  A Goal Programming formulation would have a first objective of minimizing the cost of satisfying all requirements, and perhaps a second objective of minimizing the maximum over-satisfaction of any requirement.  The Lexico approach saves the user from having to worry about exact tradeoff rates between the cost of a solution and the value of over-satisfaction.

In the following example, we look at the Preemptive Goal command applied to a small staff scheduling model.  We have staffing requirements for each of the seven days of the week.  Employees work for 5 days with two days off each week.  M represents the number of employees starting on Monday, T is the number staring on Tuesday, and so on.  The formulation for this model is:

Typically, you must accept some overstaffing in problems of this sort, but you may want to spread the overstaffing across the week.  After optimizing with the Solve command, you will notice the "clustered" overstaffing in the solution:

As the solution currently stands, all of the overstaffing occurs on Monday and Tuesday, as indicated by the nonzero values in the SLACK OR SURPLUS column for these two days.  Thus, on Monday and Tuesday we have two extra staff members, while during the remainder of the week we have none.

We would like to have extra staff, if possible, but more than one extra employee per day is not beneficial.  So we'll let Xi denote the extra workers up to a maximum of one on each day.  Then, using the Preemptive Goal command (in place of the standard Solve command), we can first minimize cost, fix cost at its optimal value, and then maximize the sum of the Xi variables.  The modified model is then:

We want to minimize total cost first, so we place the variable COST first in the objective.  The variable COST is defined in the row which is also named COST.  After minimizing COST and fixing it to it's optimal level, we want to maximize the excess staff for each day up to, at most, one person per day.  Note that since we are maximizing EXTRA,  it has a negative coefficient in the objective.

After applying the Preemptive Goal command we obtain the new solution:

Note that we now have one extra person on each of the four days Monday, Tuesday, Saturday, and Sunday as indicated by the values for the variables XM, XT, XS, and XN.  Thus, we have spread our beneficial, excess staffing out to two additional days without increasing our staffing costs.

The Preemptive Goal command may be applied to both linear and integer programs.  It may not be applied to quadratic programming models.


Solution Command
Solution Command	Accelerator: Alt+0   Button:

The Solution command sends a standard solution report to the Reports Window for the currently active model window.  Normally, LINDO automatically generates a solution report as part of the Solve command.  This automatic solution report is suppressed if you have used the Options command to place LINDO in Terse mode.  If LINDO is in Terse mode, you will need to run the Solution command to get a solution report.

 When you run the Solution command, you will be presented with the following dialog box:

Basically, LINDO is prompting you to determine if you want all values included in the solution report, or just the nonzero values.  If you request nonzeros only, then LINDO will only include the variables with values other than 0 and only the rows that are binding.  Requesting just the nonzeros can cut down considerably on the size of the solution report.

Once you determine the scope of the report, click the OK button and LINDO will begin generating the report.  An example of a small solution report follows:

The first information at the top of the solution report is the value of the objective function.  After this, the solution report is broken down into two sections.  The first section reports on the variables, and the second section reports on the rows.

In the variable section, there is one line for each variable giving the variable's name, its value, and its reduced cost.  Reduced costs are meaningful in linear and quadratic models, but, in general, should be ignored when solving integer programming models.

There are two valid, equivalent interpretations of a reduced cost.  First, you may interpret a variable's reduced cost as the amount by which the objective coefficient of the variable would have to improve before it would become profitable to bring that variable into the solution at a nonzero value.  Second, the reduced cost may be interpreted as the amount of penalty you would have to pay to introduce a variable into the solution.  Reduced costs are valid only over a finite range of a variable's value.

Next, in the rows section of the report you will find one line for each row giving the row's name (if any), its slack or surplus value, and its dual price.  The SLACK OR SURPLUS column tells you how close you are to the right-hand side limit on each constraint.  This quantity, on less-than-or-equal constraints, is generally referred to as slack, while on greater-than-or-equal constraints it is called a surplus.  If a constraint is exactly satisfied as an equality, the SLACK OR SURPLUS value will be zero.  If a constraint is violated, as in an infeasible solution, the SLACK OR SURPLUS value will be negative.  Knowing this can help you find the violated constraints in an infeasible model.

The LINDO solution report also gives a DUAL PRICE figure for each constraint.  You can interpret the dual price as the amount by which the objective would improve given a unit of increase in the right-hand side of the constraint.  Dual prices are sometimes called shadow prices, because they tell you how much you should be willing to pay for additional units of a resource.  Dual prices are meaningful in linear and quadratic models, but, in general, should be ignored when solving integer programming models.

As with reduced costs, dual prices are valid only over a limited range.  The Range command may also be used to determine the extent of these valid ranges.

The final line in the solution report gives the number of iterations, or simplex pivots, required to solve your model.  In integer programming models, LINDO will also print a branch count, which is the number of variables that the branch-and-bound solver had to branch on to arrive at a solution.


Range Command
Range Command	Accelerator: Alt+1

The Range command generates range report (i.e., sensitivity analysis) for the active model window.  Note that you will need to solve the model before attempting to use the Range command.

This range report includes:

•	the variable names with their current objective function coefficients and allowable increases and decreases on these coefficients

•	the row numbers (or names) with their current right-hand side values and allowable increases and decreases for these right-hand side values

The range report is relevant only for linear models.  A range report for integer and quadratic programs is of little practical use.

To illustrate the Range command, consider the small linear program:

Solving this model, we get the solution:

and the Range command yields the following range report:

Interpretation of the range report is as follows: the allowable increase or decrease for the objective coefficient of each variable is the amount by which that objective coefficient can be increased or decreased without causing a change in the basis (the set of nonzero variables).  The allowable increase or decrease for the right-hand-side of each row is the amount by which that right-hand side can be increased or decreased without causing a change in the basis.

We'll now make some changes to demonstrate these concepts.  Note that the allowable decrease on COMP1 is 5.  Thus, changing COMP1's objective coefficient to 15.1 = 20 - 4.9 should not cause a change in the variable values.  Making this modification to the objective, we have:

and resolving we get:

As predicted by the range report, the optimal variable values are unchanged.

Now, let's push COMP1's objective coefficient just past the allowable decrease to 14.9 so that we have:

Resolving, we get the new solution:

Note that the variable values have now changed, with COMP1 falling out of the solution.

Before moving on, we should mention that the allowable ranges in range reports are minimal values.  You can always alter a single right-hand side or objective coefficient up to the allowable range without affecting the variable values.  However, you may need to go significantly past the allowable range before you actually experience a change in the variable values.


Parametrics Command
Parametrics Command	Accelerator: Alt+2

When reading about the Range command above, you may have been curious as to what happens to your model when you vary an objective coefficient or a right-hand side value over its entire range - not just the allowable range listed in the range report.  Of course, you could do this by hand as follows:  alter a coefficient just beyond its allowable range, resolve, and repeat.  However, this could quickly become tedious.  LINDO's Parametrics command will automate this process for right-hand side values (at present, LINDO does not support objective coefficient parametrics).  The Parametrics command will generate a report and/or graph detailing the changes in the objective value as a function of changes in a specified right-hand side value.  You specify a new right-hand side and LINDO then changes the current right-hand side in steps to the new right-hand side value, displaying the objective function value at each step.

To have LINDO parametrically vary a right-hand side value, solve your model then select the Parametrics command.  To illustrate, suppose we have just solved the following staff scheduling model:

Next, we issue the Parametrics command and are presented with this dialog box:

First, we must select a row and enter it into the box labeled "Parametric Row".  Suppose we want to see how our staffing costs are influenced by increasing staffing on Saturdays.  In this case, the row labeled "SAT" will be our parametric row.  We can type SAT into the Parametrics Row box, or simply double-click on SAT in the list box below.  Our dialog box will then look like:

Once we select our row, LINDO displays the row's type (<=, = or >=) and current right-hand side value in the lower left corner of the dialog box.  Let's suppose we want to trace the effects of increasing Saturday's staff to a total of forty employees.  We would change the current right-hand side value of 12 to 40 in the box labeled "New RHS Value".  Next, we move to the Report Types section in the lower right corner of the dialog box where we have the option of selecting a text report and/or a graphics report.  If you select a graphics report, you may also choose to display the graphics in either two or three dimensions.  For our purposes, let's select both a text report and a 3D graphics report.  Input to the Parametrics dialog is complete, and we have:

Next, we click on the OK button to generate our parametric reports.  The text report is sent to the Reports window, and appears as follows:

The Parametrics text report shows the entering and leaving variables for every pivot, the right-hand side value as it changes from the current value to the new right-hand side value, the dual price, and the objective value of the new solution.  Each line in the report represents a "breakpoint" in the piecewise linear (or piecewise quadratic if the model is quadratic) relationship between the objective value and the right-hand side value.  The graphics report clearly illustrates this relationship.  This report, if requested, will appear in an individual window.  The graphics generated for this small example appears as follows:

The right-hand side is represented on the horizontal axis and the objective value on the vertical axis.

Ostensibly, the Parametrics command allows you to change the right-hand side of at most one constraint at a time.  Realize, however, that a simple device allows you to change several right-hand sides simultaneously in a linear fashion.  Let the change column be called D.  It may have coefficients in any or all rows.  Add a constraint D = 0, and then do parametric analysis on the RHS of this constraint.

The Parametrics command may be applied to linear and quadratic programs, but is not applicable to integer programs.


Statistics Command
Statistics Command	Accelerator: Alt+3

The Statistics command sends a small report to the Reports window.  This report contains a number of summary statistics concerning the active model window.

As an illustration, consider the following model:

Issuing the Statistics command for this model yields the following report:

Below is a brief description of each of these statistics:

1)	number of rows

2)	number of variables

3)	number of integer variables, with the number that are 0/1

4)	QCP is the index of the first real constraint in a quadratic program (0 indicates this is not a quadratic program)

5)	number of nonzero coefficients in the whole model

6)	number of nonzero coefficients in the constraints, with the number that are +1 or -1

7)	model density, defined as: (number of nonzeros) / [(number of rows) * (number of columns + 1)]

8)	absolute values of the smallest and largest nonzeros

9)	sense of the objective function (MIN or MAX)

10)	number of less-than-or-equal-to, equality, and greater-than-or-equal-to constraints

11)	upper bound estimate of the number generalized upper bound (GUBS) constraints  constraints which have no variable in common

12)	lower bound estimate of the number of variable upper bounds (VUBS). For example, the constraint X1 + X2 - X3 = 0 contains the implications:

X3 = 0 implies X1 = 0

X3 = 0 implies X2 = 0

13)	the number of columns with only one nonzero coefficient

14)	the number of redundant columns, i.e., columns identical to some other column except possibly for the bounds

The Statistics command can be used for checking for certain types of errors in your model.  For example, if there is a misspelled variable name, you may find columns with a single nonzero element when you don't expect any.  If you misplace a decimal point in the model, you may find a value that is unexpectedly large or small in absolute value.


Peruse Command
Peruse Command	Accelerator: Alt+4   Button:

The Peruse command can be used to view, or peruse, selected portions of a model's solution and/or structure.  (For old time LINDO users, the Peruse command is an enhanced version of the CPRI and RPRI commands.)  Peruse reports are generated in text and/or graphics format.  The ability to focus on specific parts of a model and its solution through the use of Peruse is particularly useful on large models, where attempting to sift through an entire formulation or solution can prove to be an overwhelming task.

In order to use all the features of the Peruse command you should first run the Solve command on your model (although this is not required).  Next, issue the Peruse command, and LINDO posts the following dialog box:

The Peruse command will report on either columns or rows.  So, depending on the type of report desired, you will need to press either the Columns or Rows button in the box labeled "Orientation".

Next, you need to check off the items you want included in the report in the box labeled "View Items".  A list of candidate items and their definitions are listed below (note that the definition of a report item depends on whether the report is oriented towards columns or rows):

Report Item	Column Definition	Row Definition
Name	Column name	Row name
Primal	Column value	Row slack/surplus
Dual	Reduced cost	Dual price
Rim	Objective coefficient	Right-hand side
Upper bound	Upper bound	N/A
Lower bound	Lower bound	N/A
Type	"C" for continuous, "F" for free, and "I" for integer	"<" for less than or equal to, "=" for equality, and ">" for greater than or equal to
Nonzeros	Column nonzero count	Row nonzero count
Next, you may optionally input a condition that you can use to "filter" out unwanted columns or rows from the report.  We will discuss this feature in more detail below.

The remaining options deal with the format of your report.  The first option in this regard is to select the type of report.  You may select a text based report, a graphical report, or both.  Text reports are routed to the Reports Window.  Graphics reports are placed in individual windows.  If you choose a text based report, then you also have the options of suppressing column headers and comma delimiting the data.  If you select a graphics report, you can specify one of any of the following graph types:  area, bar, line, pie, and point.  You can also opt to display graphs in either two or three dimensions.  Finally, in graphics reports, you can optionally specify a graph title.

Once you've sorted through these various options, press the OK button to generate the report.

As an example, consider the following, staff scheduling model:

In this model Xi represents the number of employees that start on day i of the week.  Each employee works for five consecutive days, with two days off.  When we solve this model, we get the following solution report:

Let's create a text report and a graphics report that display the column values.  For the graphics format we'll use a 3D bar chart.  The Peruse command dialog box should be filled in so that it resembles:

The text report is sent to the Reports Window, and appears as follows:

The graphics report is sent to an individual window and is shown below:

As we mentioned above, you can input a condition as part of the Peruse command to filter out unwanted columns and rows.  This feature is particularly useful when perusing large models, where unconditional reports would be unwieldy.  The conditional expression is evaluated for each row and column.  If the expression evaluates to true, then the row or column is added to the report.  If the expression is false, it is skipped.  When constructing conditional expressions, there is a set of eight symbols that you may use that correspond to the eight report items mentioned above.  These symbols are listed below:

Report Item	Symbol
Name	N
Primal	P
Dual	D
Rim	R
Upper bound	U
Lower bound	L
Type	T
Nonzeros	Z
In addition to these symbols, the following table lists a number of different operators that may be applied to the symbols when constructing conditional expressions:

Operator	Function
%	Wild card character placeholder for use in forming variable name templates
+	Addition
-	Subtraction
/	Division
*	Multiplication
^	Exponentiation
LOG(x)	Natural logarithm of x
EXP(x)	e x
ABS(x)	Absolute value of X
.AND.	Logical and
.OR.	Logical or
.NOT.	Logical not
>	Compare, greater than
<	Compare, less than
=	Compare, equal to
#	Compare, not equal to
()	Parentheses for specifying precedence
As an illustration, in our example above there were several days of the week when we do not start any employees.  Suppose we want to eliminate these days from our reports.  We can do this by only including the columns with primal values greater than 0.  A conditional expression that will enforce this is:  P > 0.  We enter this expression into the edit box labeled "Condition" as shown here:

Now, our graph includes only the days where the number of starting employees is greater than 0:


Picture Command
Picture Command	Accelerator: Alt+5   Button:

The Picture command displays a model in matrix form.  You may request either a text or graphical representation of the matrix of nonzero coefficients.  This command is a useful way to obtain a visual impression of your model.

Viewing the model in matrix form can be helpful in a couple of instances.  First, a nonzero picture can be helpful when you are attempting to identify special structure in your model.  As an example, if your model displays strong, block angular structure, then algorithms that decompose the model into smaller fragments might prove fruitful.  Secondly, and perhaps most importantly, is the use of nonzero pictures in debugging formulations.  Most linear programming models have strong repetitive structure.  Incorrectly entered sections of the model will stand out in a nonzero picture.

To view a nonzero picture of a model, select the model's window by clicking on it with the mouse.  Next, issue the Picture command.  You should now see the Nonzero Picture dialog box:

Your first option is to decide if you want LINDO to permute the rows and columns in an attempt to maximize the number of nonzeros appearing beneath the matrix diagonal.  A model that can be permuted with most of the nonzero elements appearing beneath the diagonal tends to be relatively easier to solve.  If you want LINDO to permute the rows and columns, press the button labeled "Lower Triangular", otherwise, press the "None" button.

Your next option is to select the Picture Type.  You can select a graphics report, a text based report, or both.  Graphics reports will be sent to individual windows.  Text reports are routed to the Reports Window.

As an illustration, we will create nonzero picture reports for the following model:

We will choose to not have LINDO permute the rows and columns into lower triangular form and we will generate both text and graphics reports.  So, we issue the Picture command and fill in the dialog box as follows:

After we press the OK button, our text and graphics reports are generated and will appear as follows:

Text Nonzero Picture Report

Graphics Nonzero Picture Report

In the text report, variable names are printed vertically along the top, row names appear on the left, and right-hand side values appear on the right along with the direction of the row.  Nonzero matrix coefficients appear in their appropriate positions in the matrix.  Note that coefficients that are integer valued in the range 1 to 9 are printed without modification.  Alphabetic letters are substituted for all other coefficients using the the following scheme:

Letter Code	Coefficient Range
Z	.000000         .000001
Y	.000001         .000009
X	.000010         .000099
W	.000100         .000999
V	.001000         .009999
U	.010000         .099999
T	.100000         .999999
A	1.000001       10.000000
B	10.000001      100.000000
C	100.000001     1000.000000
D	1000.000001    10000.000000
E	10000.000001   100000.000000
F	100000.000001  1000000.000000
G	>1000000.000000
The text versionc of the nonzeros picture report complies with the Terminal Width parameter, which may be reset using the Edit|Options command.  Thus, if the width of the picture exceeds the Terminal Width parameter, the report will be continued on additional pages.  You may want to increase the Terminal Width to maximize the amount of output per page in the text report.

The graphics version of the nonzero picture report displays the model's name across the top, the model dimensions across the bottom, and, space permitting, the row names along the left and variable names across the top.  Negative coefficients are displayed using red rectangles, while positive coefficients are displayed in blue.  If there is enough space in a rectangle, the actual coefficient value will also be displayed.

Along the right of the graphics report you will notice three "tools" represented by the following icons:

The uppermost tool (the magnifying glass with a plus sign) is the zoom-in tool.  To select this tool, click the button immediately to its left.  The mouse cursor will then take on the appearance of the zoom-in tool ( [image]).  You may then position the mouse over an area of the matrix you wish to examine more closely, click the mouse, and LINDO will zoom in around the area you selected.  Using the model presented above, we used the zoom-in tool to enlarge rows 1 through 3 and columns P2T1 through I1T2:

Note that by zooming in there is enough space to begin displaying nonzero coefficient values and the variable names along the top of the picture. In addition, scroll bars have been added to the picture to allow you to scroll vertically and horizontally through the matrix.

You may zoom out in an identical manner by selecting the zoom out tool ( [image]).

The arrow tool ( [image]) can be used to select a specific area of the matrix to enlarge.  Point to the upper left corner of the area you want enlarged, click down on the mouse button and drag to the lower right corner of the area of interest.  Finally, release the mouse button and LINDO will enlarge the selected area so that it fills the entire picture.

At present, graphical nonzero picture reports cannot be printed directly from LINDO.  However, you can issue the Copy command from the Edit Window.  This places the nonzero picture into the Windows clipboard.  From the clipboard, the picture can be pasted into any graphics program (e.g., Microsoft Paint), and printed from there.


Basis Picture Command
Basis Picture Command	Accelerator: Alt+6

The Basis Picture command displays a text format report containing a "picture" of the current basis, ordering the rows and columns according to the last inversion or triangularization performed by the solver.  The Basis Picture report is sent to the Reports Window.

We will use the Basis Picture command to display a picture of the optimal basis for the following model:

First, we optimize the model by selecting the Solve command from the Solve menu.  Then, we select the Basis Picture command from the Reports menu, and LINDO sends the following report to the Reports Window:

In the report you will note that the basis matrix has been rotated by 90 degrees.  The names of the variables appearing in the basis are displayed to the left.  The names of the rows that the variables are basic in run from right to left along the top.  Positive integer coefficients from 1 to 9 appear unaltered in the report.  For the remaining nonzero coefficients, plus (+) symbols are displayed for positive values and minus (-) symbols are displayed for negative values.

LINDO can triangularize the basis for some models (i.e., all nonzero elements contained on or below the diagonal).  Models with a triangular basis tend to solve faster than non-triangular ones.  In this particular example, the optimal basis matrix is mostly triangular, with only seven columns protruding beyond the diagonal (B2T1, B1T1, C2T1, T1T2, B1T2, T2T2, and P1T2)

There may not always be a full complement of variables in a basis.  In which case, you will see variables in the Basis Picture report titled ART.  This stands for an artificial variable, which LINDO uses as a placeholder when it has not yet assigned a variable to a row.

The Basis Picture report complies with the Terminal Width parameter, which may be reset using the Edit|Options command.  Thus, if the width of the picture exceeds the Terminal Width parameter, the report will be continued on additional pages.  You may want to increase the Terminal Width to maximize the amount of output per page in the report.


Tableau Command
Tableau Command	Accelerator: Alt+7

The Tableau command shows the current simplex tableau.  It is a useful way to observe the simplex algorithm at each step, especially when used in conjunction with the Pivot command.  The Tableau command displays the variables across the top, the row numbers in the first column on the left, the basic variable in each row in the second column, the current coefficients for each variable, and the current right-hand side on the far right.

The Tableau command may be combined with the Pivot command to monitor the internal workings of LINDO's solver.

In the following example, we alternate between the Tableau command and Pivot command to keep tabs on LINDO as it optimizes the following small model:

The following discussion assumes a modest knowledge of the workings of the simplex algorithm.  Interested readers can refer to any introductory operations research textbook to learn more.

Issuing the Tableau command, we receive a report containing the initial tableau:

The term ART stands for artificial variable, which are devices used to "jump start" the simplex algorithm.  An artificial variable is used whenever a variable has not yet been assigned to a row.  The term "SLK n" stands for the slack variable for the n-th row.  Slack variables are added internally by the solver to each inequality constraint to convert it to an equality.

The current basic variables are listed along the left.  Note that LINDO has already added all the slack variables into the basis.  The variable names appear along the top.  The updated column nonzero values are displayed beneath their column names.  The updated right-hand side values are displayed to the right.  Finally, note that LINDO has added an additional row at the bottom of the tableau.  This additional row corresponds to the simplex algorithm's Phase I objective of minimizing the sum of infeasibilities.  Once LINDO performs the first pivot and verifies that it has a feasible solution in this model, this row will be dropped from the tableau.

Glancing at the tableau, we see that variable Y is the nonbasic variable with the lowest reduced cost (-30 in row 1).  Performing the simplex ratio test on Y shows that variable Y is bounded most tightly by row 4, which limits Y to 60 = 120/2.  Thus, a good pivot candidate would be variable Y in row 4 for a value of 60.  To see if LINDO agrees, issue the Pivot command in the Solve menu.  When we do this we find that LINDO agrees with the above analysis:

Now, we run the Tableau command once more to see the effects of bringing Y into the basis:

Y has replaced SLK 4 in the list of basic variables on the left.  The current objective value of 1800 appears in the upper right hand corner.  Y's value of 60 appears in the last row in the far right hand column that contains the updated right-hand sides.

The only nonbasic variable that now offers an attractive (negative) reduced cost is variable X.  The bounding row is row 2 and limits X to 50.  Once again, we run the Pivot command and find that LINDO concurs with our analysis:

Running the Tableau command once again reveals:

At this point, there are no further attractive variables to introduce into the solution.  Therefore, we have arrived at the optimal solution.  Issuing one more Pivot command verifies this:

The Tableau report complies with the Terminal Width parameter.  Thus, if the width of the report exceeds the Terminal Width parameter, it will be continued on additional pages.  You may want to increase the Terminal Width using the Edit|Options command to maximize the amount of output per page in the report.


Formulation Command
Formulation Command    Accelerator: Alt+8

The Formulation command is used to display all, or selected segments, of your model in the Reports Window.  Longtime LINDO users will recognize that the Formulation command is equivalent to the LOOK command in command-line versions.

The Formulation command displays LINDO's internal representation of the model created from compiling the text in your model window.  Thus, all comments and special formatting will be absent.

To run the Formulation command, you must select the model window that you want to generate the report for.  Next, select the Formulation command form the Reports menu, and you will be presented with the following dialog box:

In the box labeled "Rows to view" you have the option of viewing all the rows in the model, or selected rows only.  If you choose to view selected rows, then the box labeled "Selected rows" becomes enabled and you can specify starting and ending rows to view.

Let's illustrate the Formulation command using the following small model that we have entered into a model window:

Issuing the Formulation command for this model causes the following to appear in the Reports Window:

As mentioned, this is LINDO's internal representation, and not an exact replica of the model you typed into your model window.  As such, you will notice how all comments have been removed and the text has been reformatted.  Of course, even though LINDO's internal representation appears different from the model you input, the two formulations are mathematically equivalent.

The Formulation report complies with the Terminal Width parameter.  Thus, if the width a constraint exceeds the Terminal Width parameter, the constraint will be continued onto additional lines.  You may want to increase the Terminal Width using the Edit|Options command to increase the amount of output per line in the Formulation report.


Show Column Command
Show Column Command	Accelerator: Alt+9

When you are dealing with a large model it is useful to be able to display a selected row or column without sifting through the entire formulation.  The Formulation command allows you to view a single row while the Show Column command allows you to view the details of a single column.

To run the Show Column command, you must first select the model window of interest by clicking it once with the mouse.  Next, issue the Show Column command and select the variable you want to generate the report for.  Press the OK button, and the Show Column report is sent to the Reports Window.

As an example, suppose you have solved the following, small transportation model:

When we issue the Show Column command, LINDO presents the following dialog box to assist you in selecting a column name:

The list box labeled "Column to Show" contains all the variable names.  You may type in a name directly, or select a column name from the list box.  In this example, we have chosen the variable XWH1C2.  Pressing the OK button, causes the following report to be sent to the Reports Window:

In the first line, we have the variable name and its internal index.  In this case, the internal index is 2, which means that this was the second variable LINDO encountered when it compiled the model

In the next section of the report, there is one line for each row in which the column has a nonzero coefficient.  In each line the row number, the nonzero coefficient and the row's dual price appears.

Finally, at the bottom of the report the columns value and reduced cost are printed.


Positive Definite Command

The Positive Definite command is used with quadratic programs to check whether you have a guarantee of global optimality.  It examines the submatrix of constraints corresponding to the quadratic form to determine whether this submatrix is positive definite.  If the matrix is positive definite, then the objective function of the quadratic program is convex and the solution found is guaranteed to be a global optimal solution.


Open Command Window Command
Open Command Window Command	Accelerator: Alt+C

LINDO has a macro or command language for accessing its features.  For more details on the command language, refer to the documentation under the chapter, LINDO for Command-line Environments.  A script file that contains LINDO commands may be run using the Take Commands command in the File menu.  Alternatively, you can interactively enter commands into LINDO's Command Window.  To bring up the Command Window, issue the Open Command Window command.  The following window should appear on your screen:

The colon in the upper left-hand corner is LINDO's familiar command-line prompt.  You may proceed by entering any of the valid LINDO commands.

In this next example, we enter a small model into the Command Window, display the formulation, and then solve it:

In general, you will probably prefer to use the menu and toolbar interface when running LINDO interactively.  The Command Window feature is primarily provided for users wishing to interactively test out ideas for LINDO scripts.


Open Status Window Command

When LINDO's internal solver initiates it displays a Status Window on your screen that looks like the following:

This window allows you to monitor the progress of the solver.  You can close this Status Window at any time.  If you do close it, it may be restored at any time with the Open Status Window command.

For more information on the interpretation and use of the Status Window, please refer to the  Solve command.


Send To Back Command
Send To Back Command	Button:

The Send To Back command sends the active window behind all other windows on the screen.  This command is particularly useful when switching between a model window and the Reports Window.

As an example, suppose our screen is configured with a model window appearing before the Reports Window:

Issuing the Send to Back command causes the windows to reverse position with the Reports Window moving to the front:


Cascade Command
Cascade Command	Accelerator: Ctrl+A

The Cascade command arranges all the open windows in a cascade from upper left to lower right, with the currently active window on top.

For instance, suppose our windows are positioned as follows:

After we issue the Cascade command, our windows will be repositioned in the following manner:


Tile Command
Tile Command	Accelerator: Alt+T   Button:

The Tile command arranges all the open windows in a tiled pattern.  Each window is resized so that all windows appear on the screen and are of roughly the same size.  You may choose to tile either horizontally or vertically.  If you tile horizontally (vertically), LINDO will try and maximize the horizontal (vertical) dimension of each window.  If there are more than three open windows, LINDO will tile the windows, but the choice of horizontal or vertical will no longer have an effect.

For instance, suppose we have three open windows positioned as follows:

Issuing the Tile command, we receive the following dialog box:

If we press the Horizontal button and then press the OK button, our windows are repositioned as below:


Close All Command
Close All Command	Accelerator: Alt+X   Button:

The Close All command closes all open windows and dialog boxes.  If you have made a change to a model window without saving it, you will be prompted to save the model before it is closed.


Arrange Icons Command
Arrange Icons Command	Accelerator: Alt+I

If you have minimized any open windows so that they appear as icons on the screen, you can issue the Arrange Icons command to line all the icons up in the lower left-hand corner of the frame window.


Contents Command
Contents Command	Accelerator: F1   Buttons:

The Contents Command opens LINDO's help window to the contents section.  You may examine the contents section for subjects of interest and jump to a desired topic by pressing on its text.  The Contents command may be invoked by the button:.

The [image] button is used to invoke context sensitive help.  Selecting this command turns the mouse cursor into a question mark.  Once you have the question mark prompt, selecting any command or button will take you to the relevant section of the help file.


Search for Help On Command
Search for Help On Command	Accelerator: Alt+F1

The Search for Help On command allows you to search the LINDO help system for a key word or topic.


How to Use Help Command
How to Use Help Command	Accelerator: Ctrl+F1

The How to Use Help command provides you with useful information on navigating the LINDO help system.


About LINDO Command

The About LINDO command opens a system window which provides you with information about the software you are using and LINDO Systems, Inc.  The first four lines of the window show the version of LINDO being used, the release number, the release date, and the LINDO copyright respectively.  Following the LINDO icon, the mailing address, telephone, e-mail address, and Internet address for the LINDO Systems, Inc. home office is given.  This may be useful for future reference about updated versions of the software and other LINDO Systems products.

The box at the bottom lists the constraint and variable limits of your copy of LINDO along with the physical nonzero limit.  The constraint and variable limits are determined by the version of LINDO you are using.  The limits for the Constraints and Variables respectively for each are 100 & 200 for basic LINDO, 500 & 1000 for Super (shown above), 2,000 & 4,000 for Hyper, 8,000 & 16,000 for Industrial, and 32,000 & 100,000 for Extended.  The Nonzeros limit can be set to whatever you would like by selecting Options from the Edit menu and adjusting Nonzeros limit field. We should mention that LINDO uses the nonzero allocation as a work area during optimization.  Specifically, LINDO stores the basis inverse matrix along with the structural nonzeros in this shared memory location.  Given this, you should try to allocate a good number of additional nonzeros over and above what is required by just the structural nonzeros.  If LINDO runs out of nonzero space, it halts the optimization and returns with an error.


Error Messages

The following is a list of all the error codes used by LINDO.  Press on any code number below to receive a listing of the corresponding error message and a brief description of the error.

    1	   2 	   3	   4	   5	   6	   7	   8	   9	  10

   11	  12	  13 	  14	  15	  16	   17	  18	  19	  20

   21	  22	  23	  24	  25	  26	  27	  28	  29	  30

   31	  32	  33	  34	  35	  36	  37	  38	  39	  40

   41	  42	  43	  44	  45	  46	  47	  48	  49	  50

   51	  52	  53	  54	  55	  56	  57	  58	  59	  60

   61	  62	  63	  64	  65	  66	  67	  68	  69	  70

   71	  72 	  73	  74	  75	  76	  77	  78	  79	  80

   81	  82	  83	  84	  85	  86	  87	  88	  89	  90

   91	  92	  93	  94	  95	  96	  97	  98	  99	 100

  101	 102	 103	 104	 105	 106	 107	 108	 109	 110

  111	 112	 113	 114	 115	 116	 117	 118	 119

… 120-999 Not In Use …

1000

1001	1002	1003	1004	1005	1006	1007	1008	1009	1010

1011	1012	1013	1014	1015	1016	1017	1018	1019	1020

1021	1022	1023	1024	1025	1026	1027	1028	1029	1030

1031	1032	1033	1034	1035	1036	1037	1038	1039	1040

1041	1042	1043	1044	1045	1046	1047	1048


1.	UNRECOGNIZED COMMAND.

The last command you entered was not recognized by the LINDO command processor.  Check the spelling of the command and try again.


2.	EXPECTING ''SUBJECT TO'' ... ENTER THAT OR ''END''.

The LINDO model parser was expecting to find "SUBJECT TO" or "ST" to indicate the start of the constraints.  This indicates that a syntax error has occurred.  You should enter several carriage returns to retreat to command level, examine the model with the LOOK command, and begin entering the remainder of the model with the EXTEND command.


3.	FIRST ROW SHOULD NOT HAVE A RELATIONAL OPERATOR.

The first row in a LINDO model must always be the objective row.  Given this, the first row should never contain a relational operator (e.g., <, =, or >).


4.	EXPECTING SIGN OR RELATIONAL OPERATOR.

The LINDO model parser was expecting to find a coefficient sign or a relational operator, but found something else.   This indicates that a syntax error has occurred.  You should enter several carriage returns to retreat to command level, examine the model with the LOOK command, and begin entering the remainder of the model with the EXTEND command.


5.	EXPECTING A VARIABLE COEFFICIENT.

The LINDO model parser was unable to find a variable coefficient. This indicates that a syntax error has occurred.  You should enter several carriage returns to retreat to command level, examine the model with the LOOK command, and begin entering the remainder of the model with the EXTEND command.


6.	FIRST CHARACTER OF A VARIABLE NAME MUST BE A LETTER.

The LINDO model parser did not find a variable name beginning with a alphabetic character.  This indicates that a syntax error has occurred.  You should enter several carriage returns to retreat to command level, examine the model with the LOOK command, and begin entering the remainder of the model with the EXTEND command.


7.	VARIABLE NAMES MUST BE <= 8 CHARACTERS.

The maximum number of characters allowed in LINDO variable and row names is 8.


8.	INVALID VARIABLE NAME.

You have specified a variable name that LINDO does not recognize.  Please check the spelling of the name.


9.	INVALID ROW NUMBER. REENTER ROW NO. (1 TO M).

You have entered an invalid row number or a row number that is out-of-bounds.  Please try again and enter a row number in the range of 1 to M, where M is the number of rows in the current model.


10.	ROW 1 HAS NO RHS ... REENTER ROW NUMBER.

You have attempted to ALTER the right-hand side coefficient on the objective function.  The objective function in LINDO is not allowed to have a right-hand side value.


11.	CANNOT DELETE ROW 1 ... REENTER ROW NUMBER.

LINDO requires that an objective function always be present in a model.  Thus, you may not use the DELETE command on the objective row.


12.	END INVALID EXCEPT AFTER A COMPLETE ROW.

LINDO found an END statement before the completion of model input.  This indicates that a syntax error has occurred.  You should enter several carriage returns to retreat to command level, examine the model with the LOOK command, and begin entering the remainder of the model with the EXTEND command.


13.	<Not In Use>


14.	EXPECTING A RHS VALUE

The LINDO model parser was expecting a right-hand side value, but encountered something else.  Chances are you tried to place a variable on the right-hand side which is not allowed by LINDO.  All variables must be carried over to the left-hand side of your constraints.


15.	INVALID DATA SET NAME ... PLEASE REENTER.

You have input a valid file name.  Please check the spelling and try again.


16.	<Not In Use>


17.	<Not In Use>


18.	THERE IS NO CURRENT FORMULATION IN MEMORY.

You have issued a command that requires that a formulation be in memory.  Please enter a new model with the MAX or MIN commands or read in a model from disk using the RETRIEVE or TAKE commands.


19.	<Not In Use>


20. UGH!  RETREATING TO COMMAND LEVEL.  USE LOOK, ALTER, DELETE, AND EXTEND TO VIEW DAMAGE,  MAKE MINOR REPAIRS,  DELETE A
20. 	UGH!  RETREATING TO COMMAND LEVEL.  USE LOOK, ALTER, DELETE,

AND EXTEND TO VIEW DAMAGE,  MAKE MINOR REPAIRS,  DELETE A

CONSTRAINT AND GET BACK IN INPUT MODE.

LINDO has encountered several contiguous errors in the text of your model.  Rather than attempt to go on, LINDO halts model input and returns to command level


21.	COMMAND DISREGARDED.

You have input an invalid argument to a command or you have chosen to back out of a command by entering a blank line to a prompt.  In either case, processing of the command is interrupted and you will be returned to command level.


22.	<Not In Use>


23.	TOO MANY INTEGER VARS. MUST BE <=  <N>.

LINDO places a limit on the maximum number of integer variables in a model, which you have exceeded.  In general, this limit is the same as the limit on the total number of variables.  However, some special versions of LINDO may have a lower limit on integer variables than on total variable.


24.	BAD VARIABLE NAME.

You have input an invalid variable name.  Processing of the command is terminated.  Check the spelling of the name and try again.


25.	<Not In Use>


26.	FILE TYPE NOT RECOGNIZED.

You tried to read a model file which is not in a correct format.  Be sure that the file was created by LINDO and that you are using the correct command to read the file.


27.MODEL SIZES OF:  <m>  ROWS <I> INTEGERS <n> VARIABLES, <z> NONZEROS ARE TOO BIG FOR VERSION LIMITS OF: <M> <I> <N> <Z>
27.	MODEL SIZES OF:  <m>  ROWS <I> INTEGERS <n> VARIABLES, <z> NONZEROS

ARE TOO BIG FOR VERSION LIMITS OF: <M> <I> <N> <Z>

The model you are attempting to read is too big for the limits on your version of LINDO.  Either cut back on the model's size or use a larger version of LINDO that has the capacity for this model.


28.	NO. OF VARIABLES MUST EQUAL NO. OF CONSTRAINTS.

In a quadratic programming model there is one dual variable for each real constraint and one first order condition constraint for each real variable.  Thus, in an expanded quadratic model with the first order conditions present, the total number of variables must equal the total number of constraints.  LINDO has detected that this is not the case.  Please check your model for mistakes and typographical errors.


29.	OUT OF SPACE WHILE ADDING SLACK VARIABLES.

When LINDO solves a model it adds one slack or surplus variable to each inequality row to convert it internally to an equality row.  These additional variables count against the variable limit in your version of LINDO, which you have exceeded.  Try running a larger version of LINDO.  If this is not possible, you may be able to convert some inequality constraints to equalities without loss of generality.


30.	FILE COULD NOT BE OPENED.

LINDO was unable to open a file that you specified as part of a command.  Make sure you have spelled the filename correctly and that you have access to the file.


31.	NOT ENOUGH WORKING MEMORY

LINDO did not set aside enough memory to complete the operation you specified.  Adding additional memory to your machine will not alleviate the problem.  Call technical support for assistance.


32.	INVALID COMMAND:   <Command>

TYPE "COM" TO SEE VALID COMMANDS

You have input an unknown command to the LINDO command-line prompt.  Please check the spelling of the command or give the COMMANDS command to get a list of available commands.


33.	AMBIGUOUS COMMAND:   <Command>

LINDO allows you to abbreviate commands as long as there is no possibility  for confusion.  When you abbreviate a command too much, it may be confused with other commands and LINDO issues this error message.


34.	<Not In Use>


35.	INADMISSABLE VALUE:  <Value>.  COMMAND IGNORED.

You have entered an invalid argument for a command.  Please check the documentation for this command and try again


36.	<Not In Use>


37.	<Not In Use>


38.	INVALID ROW.  DISREGARDED.

You have specified an invalid row name or number. Please check the spelling of names or be sure that row numbers are within the range of total rows in the model.


39.	COMMAND DISREGARDED: SOLVE MODEL FIRST

You have attempted a command that requires a valid solution in memory.  Use the GO command to solve the model and then try again.


40.	WARNING: OVERLENGTH LINE, CHARACTERS MAY HAVE BEEN LOST

OFF END.  USE CARRIAGE RETURN TO BREAK UP OVER SEVERAL

INPUT LINES.

You have attempted to input a line that has exceeded (or is close to exceeding) the terminal width limit.  Either shorten your input lines or use the WIDTH command-line command or the Windows Edit|Options command to increase the terminal width.


41.	<Not In Use>


42.	NAME ALREADY IN USE.

You have attempted to use the ALTER command to change a row name to a name that is already in use.  Try using a different name.


43.	INPUT WAS INVALID.

You have specified invalid input for a command.  Please refer to the documentation for the command and try again.


44<Not In Use>
44.	<Not In Use>


45.	WARNING: VARIABLE <Variable> HAS THE LOWER AND UPPER BOUNDS:

<Lower> <Upper>

You have specified inconsistent bounds.  This usually means that you have specified a lower bound that is greater than the upper bound.  Please reenter the bounds on the variable.


46.	VARIABLE NOT RECOGNIZED.

You have specified an invalid variable name as part of a command.  Please check the spelling of the name and try again.


47.	<VariableIndex>  IS NOT A VALID INTEGER VARIABLE

You have specified an improper variable index while trying to make a variable integer.  The index must lie in the range of 1 to N, where N is the total number of variables.


48.	INVALID BOUND VALUE.

You have specified an invalid value for a variable bound.  Be sure that the bound value is numeric and retry.


49.	SUB FOR INVALID VARIABLE: <VariableIndex>

You have specified an improper variable index while trying to set a simple upper bound on a variable.  The index must lie in the range of 1 to N, where N is the total number of variables.


50.	INVALID SUB: <Value> FOR VAR <VariableIndex>

You have specified an invalid value for a simple upper bound on a variable.  Be sure that the bound is numeric and that it is nonnegative.


51.	<Not In Use>


52.	UNBOUNDED SOLUTION AT STEP <N>, REDUCED COST= <Value>

USE THE "DEBUG" COMMAND FOR MORE INFORMATION.

The objective function can be increased without bound.  You have most likely misspelled a variable name or have omitted some constraints.  Run the DEBUG command to narrow down the problem.


53.	ITERATION LIMIT EXCEEDED.

LINDO has hit the limit on iterations.  You can specify your own limit as part of the GO command by typing GO N, where N is an integer value that will be used as an iteration limit.


54.	NO FEASIBLE SOLUTION AT STEP <N>.

There is no solution which simultaneously satisfies all the constraints.  Run the DEBUG command in command-line versions and the Solve|Debug command on Windows versions to try to narrow down the problem.


55.	NO INTEGER SOLUTION WAS FOUND.

Your model is LP feasible but IP infeasible.  In other words, a solution was found to the continuos relaxation of the model with integer restrictions removed.  However, no solution was found once the integer restrictions were restored.


56.	WARNING, SOLUTION MAY BE NONOPTIMAL/NONFEASIBLE.

The current solution in memory is either nonoptimal or infeasible.  Use the GO command to solve the model and then try again.


57.	NESTED ''TAKE'' FILES ARE NOT ALLOWED.

LINDO does not allow nested TAKE files.  In other words, you cannot place a TAKE command in a file you intend to do a TAKE on.


58.	MORE THAN <N> COLUMNS HAD NONZERO OBJECTIVE

COEFFICIENTS. THIS EXCEEDS THE LIMITS OF THIS VERSION.

You have too many goals in a goal programming model.  Try to eliminate some goals.


59.	FORMULATION ANOMALIES PRESENT:

FIRST ANOMALY WAS IN COLUMN <N>

OBJECTIVE COEFFICIENT NOT +1

The objective coefficients in a goal programming model should always be +1.


60.	FORMULATION ANOMALIES PRESENT:

FIRST ANOMALY WAS IN COLUMN <N>

MORE THAN 2 NONZEROS IN COLUMN WITH +1 IN OBJECTIVE ROW.

The goal variable in a goal programming model should only have 2 nonzeros - one in the objective and the other in the row defining the goal.


61.	<Not In Use>


62.	<Not In Use>


63.	INFEASIBLE MODEL ENCOUNTERED DURING GOAL PROGRAMMING.

You have attempted to solve a goal programming model that does not have any solution that simultaneously satisfies all the constraints.  Run the DEBUG command to try to narrow down the problem.


64.	UNBOUNDED MODEL ENCOUNTERED DURING GOAL PROGRAMMING.

You have attempted to solve a goal programming model that has a goal that may be increased without bound.  Run the DEBUG command to try to narrow down the problem.


65. MAXIMUM ROW LIMIT OF <M> EXCEEDED.'
65.	MAXIMUM ROW LIMIT OF <M> EXCEEDED.

LINDO has a limit on the total number of constraints in a model which you have exceeded.  You can move to a larger version of LINDO or eliminate some constraints.  Keep in mind that the default lower limit for variables in LINDO is 0, thus constraints of the form X  0 are not required.  Also, using the SUB and SLB statements do set simple bounds does not count against the constraint limit.


66.	WARNING:  PROBLEM IS POORLY SCALED.  THE UNITS

OF THE ROWS AND VARIABLES SHOULD BE CHANGED SO

THE COEFFICIENTS COVER A MUCH SMALLER RANGE.

LINDO prints this message when some nonzero coefficients are abnormally large or small in value.  It also computes the ratio of the smallest coefficient to the largest coefficient and will print this message if it finds this ratio excessive.  This is really just a warning, and you may be able to go ahead and solve the model without problems.  However, if LINDO seems to have a hard time solving the model you may want to attempt to scale your data.


67.	INVALID VALUE DISREGARDED

You have entered an invalid argument value as part of a command.  Please refer to the documentation for this command and try again.


68.	END ASSUMED. TOO MANY ELEMENTS.

You have too many nonzero elements in an APPCOL command.  Please check your data and try again.


69.	VARIABLE ALREADY EXISTS, COMMAND DISREGARDED.

You have attempted to append a column with a name that already exists.  Please use a different name and try again.


70.	BAD COLUMN INDEX <N> TO INSERT ROW.

You have attempted to insert a row with a bad column index.  Check your data an try again.


71.	OUT OF SPACE IN INSERT ROW ADDING ROW:  <I>

SPACE NEEDED:   <J>

SPACE AVAILABLE:  <K>

You have run out of nonzero space adding a constraint to LINDO.  Reduce the size of the model or use a larger version of LINDO.


72.	FATAL OUT-OF-SPACE CONDITION IN INVERT AT STEP <N>

LINDO has run out of working nonzero space during basis inversion.  In Windows versions you can use the Edit|Options command to increase the nonzero limit.  In other versions you may be able to increase the maximum nonzero level by creating a file in LINDO's directory called LINDO.CNF.  Set the first line in the file to be "MAXNZ=z", where z is the maximum number of nonzero elements you desire.  Restart LINDO and run the HELP command to see if you have obtained the desired number of nonzero elements.


73.	NO BASIS ORDER EXISTS.  USE INVERT FIRST.

The Basis Picture command (BPIC) requires that an active basis be present in memory.  Run the INVERT command and try again.


74.	MODEL TOO BIG TO PERMUTE.

LINDO has run out  of space while attempting to permute a model into lower triangular form for a nonzero "picture".  Increasing the nonzero limit may help (see message 72).


75.	DUPLICATE ROW IN MPS MODEL:  <Row>

A row has been declared twice in a MPS file.  Please correct the MPS file and try again.


76.	BAD CARD IN MPS MODEL:  <CardText>

An invalid record was encountered in an MPS file.  Please correct the MPS file and try again.


77.	NO OBJECTIVE ROW WAS FOUND IN THE MPS MODEL.

LINDO did not find an objective row in an MPS model.  Please add an objective to the file and retry.


78.	ERROR IN MPS MODEL ON LINE:  <N>

<CardText>

An invalid record was encountered in an MPS file on line number <n>.  Please correct the MPS file and try again.


79.	OUT OF PLACE INTEGER MARKER CARD IN LINE:

<CardText>

LINDO requires that integer variables appear first in the variable set in an MPS file.  Please move integers to the front and try again.


80.	WARNING: UNTERMINATED MARKER SET.

The integer variable set was not terminated.  All variables will be made integer.  This is just a warning, and it is not mandatory that you correct this in order to proceed.


81.	BAD VARIABLE IN BOUNDS SECTION OF MPS MODEL IN LINE <N>

An invalid variable name was specified in the BOUNDS section of an MPS file on line number <N>.  Please check the spelling of the variable name and retry.


82.	BAD BOUND <BoundValue> IN BOUNDS SECTION OF MPS MODEL IN

LINE: <N>

An invalid bound value was specified in the BOUNDS section of an MPS file.  Be sure that you have specified a numeric value and be sure that the bound value is lined up in the correct columns and retry.


83.	UNRECOGNIZED BOUND TYPE IN MPS MODEL ON LINE:  <N>

You have used an invalid bound type in an MPS model file on line <N>.  The bound type recognized by LINDO are FX, UP, LO, FR, BV, UI, and LI.  Please correct the bound type and try again.


84.	BAD RANGE IN MPS MODEL ON LINE:

<CardText>

You have specified a range on a row that does not exist.  Check the spelling of the row name and try again.


85.	*** WARNING ***

<N> ERRORS INPUTTING MPS FILE.

CORRECT EXECUTION UNLIKELY.

LINDO encountered <N> errors while processing your MPS file.  This is a warning and will not terminate processing of the file.  However, if any of the errors were unexpected you should correct them before proceeding.


86.	PROBLEM TOO BIG:

DATA INPUT IS FINISHED.

<M> ROWS

<N> COLUMNS

<Z> NONZERO ELEMENTS

Your MPS model has hit an internal limit of your version of LINDO.  LINDO prints the total number of rows, columns and nonzeros read before interrupting processing of the file.  To determine the limits of your version give the Help|About LINDO command in Windows, or give the HELP command in command-line versions.  Note that in some versions of LINDO you can increase the nonzero limit (see error message 72).


87.	RETRIEVAL ABORTED

LINDO has interrupted processing of your MPS file due to errors in the file.  Please correct any errors and retry.


88.	END OF FILE ENCOUNTERED IN MPS FILE, LINES READ: <N>

LINDO has encountered a premature end of file in your MPS format file.  Perhaps part of the file is missing or you omitted the ENDATA card at the end of the file.  Please correct and retry.


89.	NONEXISTENT COLUMN NAME ON THE FOLLOWING BASIS RECORD:

<CardText>

LINES READ= <N>

LINDO encountered an invalid variable name while reading an MPS format basis file.  Perhaps this basis file does not correspond to the current model or the variable name is spelled incorrectly.  Please correct and retry.


90.	THE FOLLOWING RECORD HAD AN INVALID STATUS:

<CardText>

THE RECORD IS IGNORED.

LINES READ= <N>

LINDO did not recognize a record type in an MPS format basis file.  The type recognized by LINDO are XL, XU, LL, UL, or IV.  Please correct and retry.


91.	NONEXISTENT ROW NAME ON THE FOLLOWING BASIS RECORD:

<CardText>

LINES READ= <N>

LINDO encountered an invalid row name while reading an MPS format basis file.  Perhaps this basis file does not correspond to the current model or the row name is spelled incorrectly.  Please correct and retry.


92.	THE MODEL MUST BE SOLVED FIRST.

You have attempted to print an MPS format solution report without first solving your model.  Please solve the model using the Solve command in Windows versions and the GO command in command-line versions then try again.


93.	THE ROW ON THE FOLLOWING LINE IS NOT BASIC:

<CardText>

You have tried to make a column basic in a row that already has a column assigned to it.  This is merely a warning.  If it is unexpected, you should correct the problem and retry.


94.	ROW <RowName> HAS WRONG BOUND - OPPOSITE BOUND SET.

You have attempted to set a slack variable to an infinite bound.  Please correct and retry.


95.	THE COLUMN ON THE FOLLOWING LINE IS BASIC:

You have attempted to make a column basic that was already basic.  Please correct and retry.


96.	THE COLUMN ON FOLLOWING CARD IS NOT AN INTEGER VARIABLE:

<CardText>

LINES READ= <N>

You have attempted to fix a variable, using the "IV" status, that is not an integer variable.  Please correct and retry.


97.SEARCH TERMINATED DUE TO USER INTERRUPT OR NUMERICAL
97.	<Not In Use>


98.<Not In Use>
98.	SEARCH TERMINATED DUE TO USER INTERRUPT OR NUMERICAL

PROBLEMS.

The LINDO solver was interrupted prematurely.  This is generally the result of the user interrupting the solver.  In this case, LINDO will return with the best solution found so far.  If you did not interrupt the solver, then LINDO encountered numerical problems and you should not rely on the reported results.


99.	<Not In Use>


100.	<Value> IS NOT A VALID INTEGER VALUE.

You have input a non-integral value to a command that was expecting an integer.  Please retry specifying an integer value.


101.	BAD INPUT TO NDXOFV: <I1> <I2> <VariableName>

You have passed invalid values to the user interface routine NDXOFV.  Please see the documentation on this routine and correct your input values.


102.	SOLUTION STATUS NOT OPTIMAL AT START OF PARAMETRICS.

LINDO must have an optimal solution in memory in order to perform right-hand side parametrics.  Please use the Solve command in Windows or the GO command in command-line versions to optimize the model and then retry.


103.	INVALID OPTION FIELD IN COMMAND.

You have specified an invalid option in the print-list of a CPRI or RPRI command.  Valid options are N, P, D, R, U, T, and Z.  Refer to the documentation on these commands for help and try again.


104.	INVALID SYMBOL IN COMMAND.

You have used an invalid symbol in the conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO.  Refer to the documentation for these commands for help.


105.	UNMATCHED PARENTHESES IN CONDITIONAL EXPRESSION.

You have unmatched parentheses in the conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO.  Add or remove parentheses as required and retry.


106.	INSTRUCTION LIST OVERFLOW IN CONDITIONAL EXPRESSION.

You have too many instructions in the conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO.  Try reducing the size of the conditional expression and try again.


107.TEMPORARY OPERATOR STACK OVERFLOW IN CONDITIONAL
107.	TEMPORARY OPERATOR STACK OVERFLOW IN CONDITIONAL EXPRESSION.

The conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO is too complex.  Try simplifying or reducing the size of the conditional expression and try again.


108.	IMMEDIATE TEXT LIST OVERFLOW IN CONDITIONAL EXPRESSION.

You have too many text operands in the conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO.  Try reducing the number of text operands in the conditional expression and try again.


109.	NUMERIC STACK OVERFLOW IN CONDITIONAL EXPRESSION.

The conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO is too complex.  Try simplifying or reducing the size of the conditional expression and try again.


110.	TEXT STACK OVERFLOW IN CONDITIONAL EXPRESSION.

The conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO is too complex.  Try simplifying or reducing the size of the conditional expression and try again.


111.	UNDEFINED OPERATION IN CONDITIONAL EXPRESSION.

The conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO contains an undefined operation (e.g., division by 0).  Correct this problem and try again.


112.CONDITIONAL EXPRESSION DOES NOT EVALUATE TO A BOOLEAN
112.	CONDITIONAL EXPRESSION DOES NOT EVALUATE TO A BOOLEAN VALUE.

The conditional expression in a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO must evaluate to either TRUE or FALSE to be considered valid.  Correct this problem and try again.


113.	REQUESTED OUTPUT LINE LENGTH EXCEEDS TERMINAL WIDTH.

The text report line length implied by a Reports|Peruse command in a Windows version of LINDO or in a CPRI/RPRI command in a command-driven version of LINDO exceeds the terminal width.  The terminal width may be increased using the Edit|Options command in Windows versions or the WIDTH command in command-line versions.  Alternatively, you can cut down on the amount of requested output.  If you are running under windows and all you want is a graphical view of the data, you can cancel the request for a text based report.


114.	INVALID QCP ROW, COMMAND DISREGARDED.

You have specified an invalid row number as part of the QCP command.  Check your model to determine the valid range for rows.  Be sure to use the row's number and not its name.


115. EXPECTING VARIABLE OR COEFFICIENT.

Your model contains a syntax error.  LINDO was expecting a variable or a variable coefficient but found something else.  For more details on model syntax, Click Here.


116. EXPECTING VARIABLE.

Your model contains a syntax error.  LINDO was expecting a variable but found something else.  For more details on model syntax, Click Here.


117. EXPECTING SIGN, VARIABLE, COEFFICIENT OR RELATIONAL OPERATOR.

Your model contains a syntax error.  LINDO was expecting a sign, a variable, a variable coefficient, or a relational operator but found something else.  For more details on model syntax, Click Here.


118. EXPECTING MIN(IMIZE) OR MAX(IMIZE)
118. EXPECTING MIN(IMIZE) OR MAX(IMIZE).

LINDO expects to find an objective function at the start of a model.  An objective function must begin with either of the keywords MAX or MIN depending upon the desired direction.  An example of a valid objective function would be:

MAX  2X + 3Y

For more details on model syntax, Click Here.


119. EXPECTING "SUBJECT TO" OR SIGN.

Before inputting your constraints, your objective function must be terminated by either SUBJECT TO or ST. For more details on model syntax, Click Here.


1000.	Toolbar installation failed.

LINDO was unable to install the command toolbar into memory on startup.  You are probably low on memory.  If other applications are running, try exiting them before starting LINDO.


1001.	Please enter a valid line number to go to.

You have input an invalid line number in the Edit|Go To Line dialog box.  Please reenter a nonnegative integer value corresponding to the line you wish to jump to.


1002.<Not In Use>
1002.	No help available on this command.

The LINDO Help System does not currently have any help available on this command.


1003.	The row values are not valid. Please reenter them.

You have input invalid row numbers or names to the Reports|Formulation dialog box.  Please enter row numbers or names that are valid for the current model.


1004.<Not In Use>
1004.	The dimensions of your model have exceeded the limits of this version.

The model is too large for the limits of this version of LINDO.  You can determine the limits of your version with the Help|About LINDO command.  You will need to cut back on the size of your model, or use a version of LINDO that has a larger capacity.

Keep in mind that simple bounds (e.g., X > 6 or X < 10) entered with the SUB and SLB statements do not count against the row limit.  Thus, converting simple bound constraints to use SUB and SLB statements can reduce the row count in a model.  Also, the default lower bound for variables is zero, thus constraints of the form X > 0 are not required.


1005.	LINDO must finish the current task before an exit is allowed.

You have attempted to exit LINDO while it is performing background calculations.  Typically, this is because the solver is currently optimizing a model.  Press the "Interrupt Solver" button on the Solver Status dialog box, then try exiting again.  If the Solver Status dialog box is not visible, use the Window|Open Status Window command to display it.


1006.	Report Window may not be closed at this time.

You have attempted to close the Reports Window while LINDO is in the middle of generating a report.  You will have to wait until the report is complete before closing the window.  If the report is excessively long, you may want to use the File|Log command to divert it to disk.  Diverting a file to disk is quicker that sending it to the Reports Window.


1007.	Windows is running low on space. Try closing some windows.

LINDO has received a low memory warning from Windows.  This generally occurs when you are trying to place too much text in an Edit window.  Edit windows can only hold up to about 64000 characters.  If you need more capacity than this, use a View Window instead.  View Windows may be opened with the File|View command.  Click here for additional information concerning the differences between Edit and View windows.


1008.	Please select some text first.

You have issued a command that requires you to select a box of text.  Please select some text by clicking with the mouse and dragging and then try the command again.


1009.	<Not In Use>


1010.	Nothing in clipboard to paste!

You have issued the Edit|Paste command when there was no text in the Windows clipboard.  Use the Copy command in LINDO or some other application to select some text and try Paste again.


1011.	Unable to Solve ... no model currently in memory!

You have issued a Solve command without a model in memory.  Select a model window by clicking on it and reissue the Solve command.


1012.	LINDO is busy right now. Try again later.

LINDO is busy performing critical background computations and is unable to handle your request at the moment.  Please try the request later.


1013.	Error writing to LOG file.  Perhaps the disk is full?

LINDO has encountered an error writing to a log file open with the File|Log command.  The most likely cause is a full disk.  If the disk your writing to is not full, then you may want to run diagnostics on it to determine if there is a problem.


1014.	Unable to open the LOG file.

The log file specified as part of the File|Log command could not be opened.   Perhaps you have specified an invalid drive, or a drive to which you do not have write access.  Try reissuing the command using a different drive.


1015.	Error writing to basis file.

An error has occurred writing to a basis file opened with the File|Basis Save command.  Perhaps the disk is full or you do not have write access to the drive?


1016.	Not enough memory for Find command.

LINDO did not have enough memory to execute an Edit|Find command.  Try closing other applications and any windows not currently required.  Also, if you have allocated an excessive amount of nonzero elements using Edit|Options, there may be inadequate memory available for other functions.


1017.	<Not In Use>


1018.	Cannot save file:  <FileName>

LINDO was unable to perform a successful save of the file <FileName>.  Perhaps the disk is full or you do not have write access to the specified drive.


1019.	Error writing to file: <FileName>

An error occurred writing to the file <FileName>.  Perhaps the disk is full.  If not, you may need to run diagnostics on your drive to determine if there is a problem.


1020.	Could not open file: <FileName>

LINDO could not open the file <FileName>.  Perhaps you do not have the required privileges to access this file, or you may need to run diagnostics on your drive to determine if there is a problem.


1021.	<Not In Use>


1022.	Could not read file: <FileName>

LINDO experienced a read error on file <FileName>.  Perhaps you do not have the required privileges to access this file, or you may need to run diagnostics on your drive to determine if there is a problem.


1023.	Not enough memory to complete command.

LINDO was unable to access enough memory to complete the command you just issued.  Try closing other applications and any windows not currently required.  Also, if you have allocated an excessive amount of nonzero elements using Edit|Options, there may be inadequate memory available for other functions.


1024.	Error attempting to load the file into a window.

This error is most likely the result of either low memory (see previous message 1023), a file too large for a model window (see message 1027), or a disk error (see message 1022).


1025.	<Not In Use>


1026.	An error occurred during compilation on line: <N>

LINDO was unable to successfully compile your model due to a syntax error on line <N>.  Use the Edit|Go To Line command to jump to this line and correct the syntax error.  Keep in mind that LINDO does its best to point to the line where the syntax error actually occurred, but it may not always nail the line down precisely.  So, be sure to examine surrounding lines in addition to the one specified by LINDO.


1027.Model is too large for an Edit Window.  Please use the File View command
1027.	Model is too large for an Edit Window.  Please use the File View command instead.

You have attempted to open a model with the File|Open command that contains more characters than can be handled in a standard Edit Window.  Standard Edit Windows can only handle up to about 64000 characters.  To open a large file, use the File|View command, which is limited only by available memory.


1028.	There is no compiled model in memory.

You have issued a command that requires a compiled model in memory.  Select a model window and issue the Solve|Compile Model command and then try again.


1029.	<Not In Use>


1030.	<Not In Use>


1031.	The model must be compiled first.  Please choose the Solve|Compile Model

command first.  Or, alternatively, save the model using LINDO Text (*.ltx)

format.

You have attempted to save a file that is to be stored in either LINDO packed format (*.lpk) or MPS format (*.mps) that has not been successfully compiled.  Please select the Solve|Compile command and then retry.  If you are unable to compile for some reason, you may always save the file in LINDO text format (*.ltx).


1032.<Not In Use>
1032.	A graph may not have more than 8000 points.

The graph you have selected has too many data points.  Try to add additional restrictions to reduce the number of data points.


1033.	The selected row was not found in the current model.

You have specified a row name or row number that is not valid for the current model.  Please check the row number and retry the command.


1034.	The right-hand side value is invalid.

You have specified a right-hand side value for a constraint that is not valid.  Please be sure that you have entered a numeric value and retry the command.


1035.	Right-hand side parametrics are not permitted on the objective row.

You have attempted to perform right-hand side parametric analysis on the objective row, which is not allowed.  Either cancel the command or specify a constraint.


1036.	The current solution is nonoptimal.  Please use the Solve command first.

You have attempted to issue a command that requires a model that has been solved to optimality.  Please issue the Solve command first and then retry.


1037.	Not enough memory to generate graph.

There was insufficient free memory to complete a request for graphics.  Try closing other applications and any windows not currently required.  Also, if you have allocated an excessive amount of nonzero elements using Edit|Options, there may be inadequate memory available for other functions.


1038.	The current model is not compiled.  Please choose the Solve|Compile

Model command first.

You have attempted a command that requires that the current model be compiled.  Please issue the Solve|Compile command and then retry.


1039.	The current window is not a model window.  Please select a model

window first.

You have issued a command that requires you to first select a model window.  Click on a window that contains the desired model and then reissue the command.


1040.	The selected option field contains an invalid argument.

You have input an invalid value for one of the fields in the Edit|Options dialog box.  LINDO will highlight the first invalid value that it finds.  Please correct the highlighted value, or press the "Cancel" button.


1041.	Please select an Edit Window to paste into.

You have attempted to paste text into a window that doesn't accept pasted data (e.g., a view or graphics window).  The only windows in LINDO that accept pasted data are Edit Windows.  Edit Windows are created using either the File|Open of File|New commands.


1042.	If you wish to choose the pivot variable, you must specify a variable name

in the 'My Variable Selection' box.

You have elected to choose the pivot variable as part of the Solve|Pivot command, but have neglected to specify the variable.  Either choose a variable or let LINDO select the pivot variable.


1043.	If you wish to choose the pivot row, you must specify a row name in the

'My Row Selection' box.

You have elected to choose the pivot row as part of the Solve|Pivot command, but have neglected to specify the row.  Either choose a row or let LINDO select the pivot row.


1044.	The selected variable was not found in the current model.

You have specified a variable that does not exist in the current model.  Please be sure you have spelled the variable's name correctly and retry.


1045.	Objective row missing from beginning of model.

The objective row, which is signified by either 'MAX' or 'MIN' must appear first in a model.  Either you have omitted the objective or have placed some constraints before it.  Please edit the model to correct the problem and retry.


1046.	You may not have both an AUTOLD.DAT file and a command line input

file.  Please use one or the other.

LINDO looks for a command script file called AUTOLD.DAT when it starts up.  If this file is found, LINDO will automatically execute the commands contained therein.  You may also specify a command script file as a command-line argument to LINDO.  LINDO restricts you to doing one or the other, however.  If you attempt to use both files, you will receive this error message.


1047.	LINDO was unable to allocate sufficient space for nonzero elements.

LINDO will quit and return to Windows.

On startup, LINDO needs to allocate a minimal amount of storage for nonzero elements.  You will get this error message when this allocation fails.  Try closing other applications and any windows not currently required


1048.	LINDO was unable to save the configuration values to a file.  Check for

write access to your working directory.

LINDO stores non-default options values in a file called LINDO.CNF.  When you change the options in the Edit|Options dialog box and press the 'Save' button, LINDO writes a new copy of the LINDO.CNF file in the working directory.  If this process fails, you will receive this error message.  Either you do not have write access to the working directory, the disk is full, or you are experiencing a hardware error.


File|New Command


File|Open Command


File|View Command


File|Save Command


File|Print Command


Edit|Cut Command


Edit|Copy Command


Edit|Paste Command


Edit|Find/Replace Command


Edit|Options Command


Edit|Go To Line Command


Edit|Paste Symbol Command


Edit|Clear All Command


Solve|Solve Command


Solve|Compile Command


Reports|Solution Command


Reports|Peruse Command


Reports|Picture Command


Window|Send To Back Command


Window|Tile Command


Window|Close All Command


Help|Contents Command


Context Sensitive Help Cursor

Press this button to turn the mouse cursor into the "Context Sensitive Help" cursor.  Use this cursor to select any menu command or button to determine its function.  Press this button again to return the cursor to normal.


Preprocess Integer Programming Option
Preprocess

Requests LINDO to do a preprocess step on integer models to add "cuts" to tighten the formulation.


Preferred Branch Integer Programming Option
Preferred Branch

Sets the preferred direction for branching on integer variables.


IP Optimality Integer Programming Tolerance
IP Optimality Tolerance

A tolerance level on the desired "closeness" to the optimal solution.  E.g., .01 means we are satisfied with solutions no more that 1 percent from the optimum.  Can greatly improve performance on many IP models.


IP Variable Fixing Tolerance

Allows you to set a reduced cost hurdle for initially fixing integer variables and optimizing over a reduced branch-and-bound tree.


IP Objective Hurdle Tolerance
IP Objective Hurdle

Specifies an objective value on a known IP solution.  Can allow the branch-and-bound solver to quickly fathom a number of initial branches.


Nonzero Limit

Sets the maximum amount of nonzero work space LINDO can allocate at start up.


Iteration Limit

Sets a limit on the number of simplex pivots that the LINDO solver will perform.


Initial Constraint Tolerance

The absolute amount of violation tolerated on a constraint by the solver when it initially starts.


Final Constraint Tolerance

The absolute amount of violation tolerated on a constraint by the solver during the final stages of computing the solution.


Entering Variable Tolerance

Sets the minimal reduced cost value required of a variable to be entered into the basis.


Pivot Size Tolerance

Sets the minimal value acceptable for a pivot element.


Status Window

If checked, the Solver Status Window will automatically appear each time you solve a model.


Terse Output

When checked, LINDO operates in terse output mode, suppressing automatic solution reports after solving a model.


Page Length Limit

Sets an output line limit for the Reports Window.  When the limit is reached, LINDO halts output until you press the "More" button.


Terminal Width

Sets the output line width for the Reports Window.