CONTENTS

ILOG CPLEX 10.2 User's Manual

Meet ILOG CPLEX
Languages and APIs
ILOG Concert Technology for C++ Users
Gray bulletArchitecture of a CPLEX C++ Application
Gray bulletLicenses
Gray bulletCompiling and Linking
Gray bulletCreating a C++ Application with Concert Technology
Gray bulletModeling an Optimization Problem with Concert Technology
Gray bulletModeling Classes
Gray bulletData Management Classes
Gray bulletSolving the Model
Gray bulletExtracting a Model
Gray bulletInvoking a Solver
Gray bulletChoosing an Optimizer
Gray bulletControlling the Optimizers
Gray bulletAccessing Solution Information
Gray bulletAccessing Solution Status
Gray bulletQuerying Solution Data
Gray bulletAccessing Basis Information
Gray bulletPerforming Sensitivity Analysis
Gray bulletAnalyzing Infeasible Problems
Gray bulletSolution Quality
Gray bulletModifying a Model
Gray bulletDeleting and Removing Modeling Objects
Gray bulletChanging Variable Type
Gray bulletHandling Errors
Gray bulletExample: Optimizing the Diet Problem in C++
Gray bulletProblem Representation
Gray bulletCreating a Model Row by Row
Gray bulletCreating a Model Column by Column
Gray bulletApplication Description
Gray bulletCreating Multi-Dimensional Arrays with IloArray
Gray bulletUsing Arrays for Input/Output
Gray bulletSolving the Model with IloCplex
Gray bulletComplete Program
ILOG Concert Technology for Java Users
Gray bulletArchitecture of a CPLEX Java Application
Gray bulletLicenses
Gray bulletCompiling and Linking
Gray bulletCreating a Java Application with Concert Technology
Gray bulletModeling an Optimization Problem with Concert Technology
Gray bulletUsing IloModeler
Gray bulletThe Active Model
Gray bulletBuilding the Model
Gray bulletSolving the Model
Gray bulletAccessing Solution Information
Gray bulletChoosing an Optimizer
Gray bulletSolving a Single Continous Model
Gray bulletSolving Subsequent Continuous Relaxations in a MIP
Gray bulletControlling ILOG CPLEX Optimizers
Gray bulletParameters
Gray bulletPriority Orders and Branching Directions
Gray bulletMore Solution Information
Gray bulletWriting Solution Files
Gray bulletDual Solution Information
Gray bulletBasis Information
Gray bulletInfeasible Solution Information
Gray bulletSolution Quality
Gray bulletAdvanced Modeling with IloLPMatrix
Gray bulletModeling by Column
Gray bulletExample: Optimizing the Diet Problem in Java
Gray bulletModifying the Model
ILOG Concert Technology for .NET Users
Gray bulletDescribe
Gray bulletModel
Gray bulletBuild by Rows
Gray bulletBuild by Columns
Gray bulletSolve
Gray bulletGood Programming Practices
Gray bulletExample: Optimizing the Diet Problem in C#.NET
ILOG CPLEX Callable Library
Gray bulletArchitecture of the ILOG CPLEX Callable Library
Gray bulletLicenses
Gray bulletCompiling and Linking
Gray bulletUsing the Callable Library in an Application
Gray bulletInitialize the ILOG CPLEX Environment
Gray bulletInstantiate the Problem Object
Gray bulletPut Data in the Problem Object
Gray bulletOptimize the Problem
Gray bulletChange the Problem Object
Gray bulletDestroy the Problem Object
Gray bulletRelease the ILOG CPLEX Environment
Gray bulletILOG CPLEX Programming Practices
Gray bulletVariable Names and Calling Conventions
Gray bulletData Types
Gray bulletOwnership of Problem Data
Gray bulletProblem Size and Memory Allocation Issues
Gray bulletStatus and Return Values
Gray bulletSymbolic Constants
Gray bulletParameter Routines
Gray bulletNull Arguments
Gray bulletRow and Column References
Gray bulletCharacter Strings
Gray bulletChecking Problem Data
Gray bulletCallbacks
Gray bulletPortability
Gray bulletFORTRAN Interface
Gray bulletC++ Interface
Gray bulletManaging Parameters from the Callable Library
Gray bulletExample: Optimizing the Diet Problem in the Callable Library
Gray bulletProblem Representation
Gray bulletProgram Description
Gray bulletSolving the Model with CPXlpopt
Gray bulletUsing Surplus Arguments for Array Allocations
Gray bulletExample: Using Query Routines lpex7.c
Programming Considerations
Developing CPLEX Applications
Gray bulletTips for Successful Application Development
Gray bulletPrototype the Model
Gray bulletIdentify Routines to Use
Gray bulletTest Interactively
Gray bulletAssemble Data Efficiently
Gray bulletTest Data
Gray bulletChoose an Optimizer
Gray bulletProgram with a View toward Maintenance and Modifications
Gray bulletUsing the Interactive Optimizer for Debugging
Gray bulletEliminating Common Programming Errors
Gray bulletCheck Your Include Files
Gray bulletClean House and Try Again
Gray bulletRead Your Messages
Gray bulletCheck Return Values
Gray bulletBeware of Numbering Conventions
Gray bulletMake Local Variables Temporarily Global
Gray bulletSolve the Problem You Intended
Gray bulletSpecial Considerations for Fortran
Gray bulletTell Us
Managing Input and Output
Gray bulletUnderstanding File Formats
Gray bulletWorking with LP Files
Gray bulletWorking with MPS Files
Gray bulletConverting File Formats
Gray bulletUsing Concert XML Extensions
Gray bulletUsing Concert csvReader
Gray bulletManaging Log Files
Gray bulletCreating, Renaming, Relocating Log Files
Gray bulletClosing Log Files
Gray bulletControlling Message Channels
Gray bulletParameter for Output Channels
Gray bulletCallable Library Routines for Message Channels
Gray bulletExample: Callable Library Message Channels
Gray bulletConcert Technology Message Channels
Licensing an Application
Gray bulletTypes of ILM Runtime Licenses
Gray bulletFile-Based RTNODE, RTSTOKEN or TOKEN Keys
Gray bulletMemory-Based RUNTIME Keys
Gray bulletRoutines and Methods Used for Licensing
Gray bulletExamples
Gray bulletCPXputenv Routine for C and C++ Users
Gray bulletThe putenv Method for Java Users
Gray bulletThe Putenv Method for .NET Users
Gray bulletCPXRegisterLicense Routine for C and C++ Users
Gray bulletThe registerLicense Method for Java Users
Gray bulletThe RegisterLicense Method for .NET Users
Gray bulletSummary
Continuous Optimization
Solving LPs: Simplex Optimizers
Gray bulletChoosing an Optimizer for Your LP Problem
Gray bulletAutomatic Selection of Optimizer
Gray bulletDual Simplex Optimizer
Gray bulletPrimal Simplex Optimizer
Gray bulletNetwork Optimizer
Gray bulletBarrier Optimizer
Gray bulletSifting Optimizer
Gray bulletConcurrent Optimizer
Gray bulletParameter Settings and Optimizer Choice
Gray bulletTuning LP Performance
Gray bulletPreprocessing
Gray bulletStarting from an Advanced Basis
Gray bulletSimplex Parameters
Gray bulletDiagnosing Performance Problems
Gray bulletLack of Memory
Gray bulletNumeric Difficulties
Gray bulletDiagnosing LP Infeasibility
Gray bulletCoping with an Ill-Conditioned Problem or Handling Unscaled Infeasibilities
Gray bulletInterpreting Solution Quality
Gray bulletFinding a Conflict
Gray bulletRepairing Infeasibility: FeasOpt
Gray bulletExample: Using a Starting Basis in an LP Problem
Gray bulletExample ilolpex6.cpp
Gray bulletExample lpex6.c
Solving LPs: Barrier Optimizer
Gray bulletIntroducing the Barrier Optimizer
Gray bulletUsing the Barrier Optimizer
Gray bulletSpecial Options
Gray bulletControlling Crossover
Gray bulletUsing SOL File Format
Gray bulletInterpreting the Barrier Log File
Gray bulletNonzeros in Lower Triangle of AAT in the Log File
Gray bulletOrdering-Algorithm Time in the Log File
Gray bulletCholesky Factor in the Log File
Gray bulletIteration Progress in the Log File
Gray bulletInfeasibility Ratio in the Log File
Gray bulletUnderstanding Solution Quality from the Barrier LP Optimizer
Gray bulletTuning Barrier Optimizer Performance
Gray bulletMemory Emphasis: Letting the Optimizer Use Disk for Storage
Gray bulletPreprocessing
Gray bulletDetecting and Eliminating Dense Columns
Gray bulletChoosing an Ordering Algorithm
Gray bulletUsing a Starting-Point Heuristic
Gray bulletOvercoming Numeric Difficulties
Gray bulletNumerical Emphasis Settings
Gray bulletDifficulties in the Quality of Solution
Gray bulletDifficulties during Optimization
Gray bulletDifficulties with Unbounded Problems
Gray bulletDiagnosing Infeasibility Reported by Barrier Optimizer
Solving Network-Flow Problems
Gray bulletChoosing an Optimizer: Network Considerations
Gray bulletFormulating a Network Problem
Gray bulletExample: Network Optimizer in the Interactive Optimizer
Gray bulletUnderstanding the Network Log File
Gray bulletTuning Performance of the Network Optimizer
Gray bulletSolving Problems with the Network Optimizer
Gray bulletNetwork Extraction
Gray bulletPreprocessing and the Network Optimizer
Gray bulletExample: Using the Network Optimizer with the Callable Library netex1.c
Gray bulletSolving Network-Flow Problems as LP Problems
Gray bulletExample: Network to LP Transformation netex2.c
Solving Problems with a Quadratic Objective (QP)
Gray bulletIdentifying Convex QPs
Gray bulletEntering QPs
Gray bulletMatrix View
Gray bulletAlgebraic View
Gray bulletExamples for Entering QPs
Gray bulletReformulating QPs to Save Memory
Gray bulletSaving QP Problems
Gray bulletChanging Problem Type in QPs
Gray bulletChanging Quadratic Terms
Gray bulletOptimizing QPs
Gray bulletDiagnosing QP Infeasibility
Gray bulletExample: Creating a QP, Optimizing, Finding a Solution
Gray bulletExample: iloqpex1.cpp
Gray bulletExample: QPex1.java
Gray bulletExample: qpex1.c
Gray bulletExample: Reading a QP from a File qpex2.c
Solving Problems with Quadratic Constraints (QCP)
Gray bulletIdentifying a Quadratically Constrained Program (QCP)
Gray bulletConvexity
Gray bulletSemi-definiteness
Gray bulletSecond Order Cone Programming (SOCP)
Gray bulletDetermining Problem Type
Gray bulletConcert Technology and QCP Problem Type
Gray bulletCallable Library and QCP Problem Type
Gray bulletInteractive Optimizer and QCP Problem Type
Gray bulletFile Formats and QCP Problem Type
Gray bulletChanging Problem Type
Gray bulletChanging Quadratic Constraints
Gray bulletSolving with Quadratic Constraints
Gray bulletNumeric Difficulties and Quadratic Constraints
Gray bulletExamples: QCP
Discrete Optimization
Solving Mixed Integer Programming Problems (MIP)
Gray bulletStating a MIP Problem
Gray bulletConsidering Preliminary Issues
Gray bulletEntering MIP Problems
Gray bulletDisplaying MIP Problems
Gray bulletChanging Problem Type in MIPs
Gray bulletChanging Variable Type
Gray bulletUsing the Mixed Integer Optimizer
Gray bulletEmphasizing Feasibility and Optimality
Gray bulletTerminating MIP Optimization
Gray bulletTuning Performance Features of the Mixed Integer Optimizer
Gray bulletBranch & Cut
Gray bulletProbing
Gray bulletCuts
Gray bulletHeuristics
Gray bulletPreprocessing: Presolver and Aggregator
Gray bulletStarting from a Solution
Gray bulletIssuing Priority Orders
Gray bulletUsing the MIP Solution
Gray bulletProgress Reports: Interpreting the Node Log
Gray bulletTroubleshooting MIP Performance Problems
Gray bulletToo Much Time at Node 0
Gray bulletTrouble Finding More than One Feasible Solution
Gray bulletLarge Number of Unhelpful Cuts
Gray bulletLack of Movement in the Best Node
Gray bulletTime Wasted on Overly Tight Optimality Criteria
Gray bulletSlightly Infeasible Integer Variables
Gray bulletRunning out of Memory
Gray bulletDifficulty Solving Subproblems: Overcoming Degeneracy
Gray bulletUnsatisfactory Subproblem Optimization
Gray bulletExamples: Optimizing a Basic MIP Problem
Gray bulletilomipex1.cpp
Gray bulletmipex1.c
Gray bulletExample: Reading a MIP Problem from a File
Gray bulletilomipex2.cpp
Gray bulletmipex2.c
Using Special Ordered Sets (SOS)
Gray bulletWhat Is a Special Ordered Set (SOS)?
Gray bulletExample: SOS Type 1 for Sizing a Warehouse
Gray bulletDeclaring SOS Members
Gray bulletExamples: Using SOS and Priority
Gray bulletilomipex3.cpp
Gray bulletmipex3.c
Using Semi-Continuous Variables: a Rates Example
Gray bulletWhat Are Semi-Continuous Variables?
Gray bulletDescribing the Problem
Gray bulletRepresenting the Problem
Gray bulletBuilding a Model
Gray bulletSolving the Problem
Gray bulletEnding the Application
Gray bulletComplete Program
Using Piecewise Linear Functions in Optimization: a Transport Example
Gray bulletPiecewise Linearity in ILOG CPLEX
Gray bulletWhat Is a Piecewise Linear Function?
Gray bulletSyntax of Piecewise Linear Functions
Gray bulletDiscontinuous Piecewise Linear Functions
Gray bulletIsolated Points in Piecewise Linear Functions
Gray bulletUsing IloPiecewiseLinear
Gray bulletDescribing the Problem
Gray bulletVariable Shipping Costs
Gray bulletModel with Varying Costs
Gray bulletDeveloping a Model
Gray bulletRepresenting the Data
Gray bulletAdding Constraints
Gray bulletChecking Convexity and Concavity
Gray bulletAdding an Objective
Gray bulletSolving the Problem
Gray bulletDisplaying a Solution
Gray bulletEnding the Application
Gray bulletComplete Program: transport.cpp
Logical Constraints in Optimization
Gray bulletWhat Are Logical Constraints?
Gray bulletWhat Can Be Extracted from a Model with Logical Constraints?
Gray bulletLogical Constraints in the C++ API
Gray bulletLogical Constraints in the Java API
Gray bulletLogical Constraints in the .NET API
Gray bulletWhich Nonlinear Expressions Can Be Extracted?
Gray bulletLogical Constraints for Counting
Gray bulletLogical Constraints as Binary Variables
Gray bulletHow Are Logical Constraints Extracted?
Using Indicator Constraints
Gray bulletWhat Is an Indicator Constraint?
Gray bulletExample: fixnet.c
Gray bulletIndicator Constraints in the Interactive Optimizer
Gray bulletWhat Are Indicator Variables?
Gray bulletRestrictions on Indicator Constraints
Gray bulletBest Practices with Indicator Constraints
Using Logical Constraints: Food Manufacture 2
Gray bulletDescribing the Problem
Gray bulletRepresenting the Data
Gray bulletWhat Is Known?
Gray bulletWhat Is Unknown?
Gray bulletWhat Are the Constraints?
Gray bulletWhat Is the Objective?
Gray bulletDeveloping the Model
Gray bulletUsing Logical Constraints
Gray bulletSolving the Problem
Gray bulletEnding the Program
Early Tardy Scheduling
Gray bulletDescribing the Problem
Gray bulletUnderstanding the Data File
Gray bulletReading the Data
Gray bulletCreating Variables
Gray bulletStating Precedence Constraints
Gray bulletStating Resource Constraints
Gray bulletRepresenting the Piecewise Linear Cost Function
Gray bulletTransforming the Problem
Gray bulletSolving the Problem
Using Column Generation: a Cutting Stock Example
Gray bulletWhat Is Column Generation?
Gray bulletColumn-Wise Models in Concert Technology
Gray bulletDescribing the Problem
Gray bulletRepresenting the Data
Gray bulletDeveloping the Model: Building and Modifying
Gray bulletAdding Extractable Objects: Both Ways
Gray bulletAdding Columns to a Model
Gray bulletChanging the Type of a Variable
Gray bulletCut Optimization Model
Gray bulletPattern Generator Model
Gray bulletChanging the Objective Function
Gray bulletSolving the Problem: Using More than One Algorithm
Gray bulletEnding the Program
Gray bulletComplete Program
Infeasibility and Unboundedness
Preprocessing and Feasibility
Managing Unboundedness
Gray bulletWhat Is Unboundedness?
Gray bulletAvoiding Unboundedness
Gray bullet Diagnosing Unboundedness
Diagnosing Infeasibility by Refining Conflicts
Gray bulletWhat Is a Conflict?
Gray bulletWhat a Conflict Is Not
Gray bulletHow to Invoke the Conflict Refiner
Gray bulletHow a Conflict Differs from an IIS
Gray bulletMeet the Conflict Refiner in the Interactive Optimizer
Gray bulletA Model for the Conflict Refiner
Gray bulletOptimizing the Example
Gray bulletInterpreting the Results and Detecting Conflict
Gray bulletDisplaying a Conflict
Gray bulletInterpreting Conflict
Gray bulletMore about the Conflict Refiner
Gray bulletUsing the Conflict Refiner in an Application
Gray bulletWhat Belongs in an Application to Refine Conflict
Gray bulletConflict Application vs Interactive Optimizer
Repairing Infeasibilities with FeasOpt
Gray bulletWhat Is FeasOpt?
Gray bulletInvoking FeasOpt
Gray bulletSpecifying Preferences
Gray bulletExample: FeasOpt in Concert Technology
Advanced Programming Techniques
User-Cut and Lazy-Constraint Pools
Gray bulletWhat Are Pools of User Cuts or Lazy Constraints?
Gray bulletAdding User Cuts and Lazy Constraints
Gray bulletUsing Component Libraries
Gray bulletUsing the Interactive Optimizer
Gray bulletReading and Writing LP Files
Gray bulletReading and Writing SAV Files
Gray bulletReading and Wrtiting MPS Files
Gray bulletDeleting User Cuts and Lazy Constraints
Using Goals
Gray bulletBranch & Cut with Goals
Gray bulletOverview of Goals in Branch & Cut
Gray bulletHow Goals Are Implemented in Branch & Cut
Gray bulletAbout the Method execute in Branch & Cut
Gray bulletSpecial Goals in Branch & Cut
Gray bulletOr Goal
Gray bulletAnd Goal
Gray bulletFail Goal
Gray bulletLocal Cut Goal
Gray bulletNull Goal
Gray bulletBranch as CPLEX Goal
Gray bulletSolution Goal
Gray bulletAggregating Goals
Gray bulletExample: Goals in Branch & Cut
Gray bulletThe Goal Stack
Gray bulletMemory Management and Goals
Gray bulletCuts and Goals
Gray bulletInjecting Heuristic Solutions
Gray bulletControlling Goal-Defined Search
Gray bulletExample: Using Node Evaluators in a Node Selection Strategy
Gray bulletSearch Limits
Using Callbacks
Gray bulletDiagnostic Callbacks
Gray bulletImplementing Callbacks in ILOG CPLEX with Concert Technology
Gray bulletWriting Callback Classes by Hand
Gray bulletWriting Callbacks with Macros
Gray bulletCallback Interface
Gray bulletThe Continuous Callback
Gray bulletExample: Deriving the Simplex Callback ilolpex4.cpp
Gray bulletImplementing Callbacks in the Callable Library
Gray bulletSetting Callbacks
Gray bulletCallbacks for Continuous and Discrete Problems
Gray bulletReturn Values for Callbacks
Gray bulletInteraction Between Callbacks and ILOG CPLEX Parallel Optimizers
Gray bulletExample: Using Callbacks lpex4.c
Gray bulletControl Callbacks for IloCplex
Gray bulletExample: Controlling Cuts iloadmipex5.cpp
Goals and Callbacks: a Comparison
Advanced Presolve Routines
Gray bulletIntroduction to Presolve
Gray bulletA Proposed Example
Gray bulletRestricting Presolve Reductions
Gray bulletAdding Constraints to the First Solution
Gray bulletPrimal and Dual Considerations in Presolve Reductions
Gray bulletCuts and Presolve Reductions
Gray bulletInfeasibility or Unboundedness in Presolve Reductions
Gray bulletProtected Variables in Presolve Reductions
Gray bulletManual Control of Presolve
Gray bulletModifying a Problem
Advanced MIP Control Interface
Gray bulletIntroduction to MIP Callbacks
Gray bulletHeuristic Callback
Gray bulletCut Callback
Gray bulletBranch Selection Callback
Gray bulletIncumbent Callback
Gray bulletNode Selection Callback
Gray bulletSolve Callback
Parallel Optimizers
Gray bulletThreads
Gray bulletExample: Threads and Licensing
Gray bulletThreads and Performance Considerations
Gray bulletNondeterminism
Gray bulletClock Settings and Time Measurement
Gray bulletUsing Parallel Optimizers in the Interactive Optimizer
Gray bulletUsing Parallel Optimizers in the ILOG CPLEX Component Libraries
Gray bulletParallel Barrier Optimizer
Gray bulletConcurrent Optimizer
Gray bulletParallel MIP Optimizer
Gray bulletMemory Considerations and the Parallel MIP Optimizer
Gray bulletOutput from the Parallel MIP Optimizer
Index