CPLEX Users Manual User's
User Manual:
Open the PDF directly: View PDF
Page Count: 586 [warning: Documents this large are best viewed by clicking the View PDF Link!]
- Contents
- Meet CPLEX
- Part 1. Languages and APIs
- Chapter 1. Concert Technology for C++ users
- Chapter 2. Concert Technology for Java users
- Architecture of a CPLEX Java application
- Creating a Java application with Concert Technology
- Modeling an optimization problem with Concert Technology in the Java API
- Solving the model
- Accessing solution information
- Choosing an optimizer
- Controlling CPLEX optimizers
- More solution information
- Advanced modeling with IloLPMatrix
- Modeling by column
- Example: optimizing the diet problem in Java
- Modifying the model
- Chapter 3. Concert Technology for .NET users
- Prerequisites
- Describe
- Step 1: Describe the problem
- Step 2: Open the file
- Model
- Step 3: Create the model
- Step 4: Create an array to store the variables
- Step 5: Specify by row or by column
- Build by Rows
- Step 6: Set up rows
- Step 7: Create the variables: build and populate by rows
- Step 8: Add objective
- Step 9: Add nutritional constraints
- Build by Columns
- Step 10: Set up columns
- Step 11: Add empty objective function and constraints
- Step 12: Create variables
- Solve
- Step 13: Solve
- Step 14: Display the solution
- Step 15: End application
- Good programming practices
- Step 16: Read the command line (data from user)
- Step 17: Show correct use of command line
- Step 18: Enclose the application in try catch statements
- Example: optimizing the diet problem in C#.NET
- Example: copying a model
- Chapter 4. Callable Library
- Architecture of the Callable Library
- Using the Callable Library in an application
- CPLEX programming practices
- Overview
- Variable names and calling conventions
- Data types
- Ownership of problem data
- Problem size and memory allocation issues
- Status and return values
- Symbolic constants
- Parameter routines
- Null arguments
- Referencing ranges of objects
- Character strings
- Checking and debugging problem data
- Callbacks
- Portability
- FORTRAN interface
- C++ interface
- Managing parameters from the Callable Library
- Example: optimizing the diet problem in the Callable Library
- Using surplus arguments for array allocations
- Example: using query routines lpex7.c
- Chapter 5. CPLEX for Python users
- Why Python?
- Meet the Python API
- Modifying and querying problem data in the Python API
- Using polymorphism in the Python API
- Example: generating a histogram
- Querying solution information in the Python API
- Examining variables with nonzero values in a solution
- Displaying high precision nonzero values of a solution
- Managing CPLEX parameters in the Python API
- Using callbacks in the Python API
- Example: displaying solutions with increased precision from the Python API
- Example: examining the simplex tableau in the Python API
- Example: solving a sequence of related problems in the Python API
- Example: complex termination criteria in a callback
- Part 2. Programming considerations
- Chapter 6. Developing CPLEX applications
- Chapter 7. Modeling assistance in CPLEX
- Chapter 8. Managing input and output
- Chapter 9. Timing interface
- Chapter 10. Tuning tool
- Part 3. Continuous optimization
- Chapter 11. Solving LPs: simplex optimizers
- Chapter 12. Solving LPs: barrier optimizer
- Introducing the barrier optimizer
- Barrier simplex crossover
- Differences between barrier and simplex optimizers
- Using the barrier optimizer
- Special options in the Interactive Optimizer
- Controlling crossover
- Using SOL file format
- Interpreting the barrier log file
- Accessing and managing the log file of the barrier optimizer
- Sample log file from the barrier optimizer
- Sample log file from the augmented system solver
- Preprocessing in the log file
- Nonzeros in lower triangle of A*A' in the log file
- Ordering-algorithm time in the log file
- Cholesky factor in the log file
- Iteration progress in the log file
- Infeasibility ratio in the log file
- Understanding solution quality from the barrier LP optimizer
- Tuning barrier optimizer performance
- Overcoming numeric difficulties
- Diagnosing infeasibility reported by barrier optimizer
- Chapter 13. Solving network-flow problems
- Choosing an optimizer: network considerations
- Formulating a network problem
- Example: network optimizer in the Interactive Optimizer
- Solving problems with the network optimizer
- Example: using the network optimizer with the Callable Library netex1.c
- Solving network-flow problems as LP problems
- Example: network to LP transformation netex2.c
- Chapter 14. Solving problems with a quadratic objective (QP)
- Chapter 15. Solving problems with quadratic constraints (QCP)
- Identifying a quadratically constrained program (QCP)
- Detecting the problem type of a QCP or SOCP
- Changing problem type in a QCP
- Changing quadratic constraints
- Solving with quadratic constraints
- Numeric difficulties and quadratic constraints
- Accessing dual values and reduced costs of QCP solutions
- Accessing dual values and reduced costs of SOCP solutions
- Examples: SOCP
- Examples: QCP
- Part 4. Discrete optimization
- Chapter 16. Solving mixed integer programming problems (MIP)
- Stating a MIP problem
- Preliminary issues
- Using the mixed integer optimizer
- Tuning performance features of the mixed integer optimizer
- Branch & cut or dynamic search?
- Introducing performance features of the MIP optimizer
- Applying cutoff values
- Applying tolerance parameters
- Applying heuristics
- When an integer solution is found: the incumbent
- Controlling strategies: diving and backtracking
- Selecting nodes
- Selecting variables
- Changing branching direction
- Solving subproblems
- Using node files
- Probing
- Cuts
- What are cuts?
- Boolean Quadric Polytope (BQP) cuts
- Clique cuts
- Cover cuts
- Disjunctive cuts
- Flow cover cuts
- Flow path cuts
- Gomory fractional cuts
- Generalized upper bound (GUB) cover cuts
- Implied bound cuts: global and local
- Lift-and-project cuts
- Mixed integer rounding (MIR) cuts
- Multi-commodity flow (MCF) cuts
- Reformulation Linearization Technique (RLT) cuts
- Zero-half cuts
- Adding cuts and re-optimizing
- Counting cuts
- Parameters affecting cuts
- Heuristics
- Preprocessing: presolver and aggregator
- Starting from a solution: MIP starts
- Issuing priority orders
- Using the MIP solution
- Progress reports: interpreting the node log
- Troubleshooting MIP performance problems
- Introducing troubleshooting for MIP performance
- Too much time at node 0
- Trouble finding more than one feasible solution
- Large number of unhelpful cuts
- Lack of movement in the best node
- Time wasted on overly tight optimality criteria
- MIP kappa: detecting and coping with ill-conditioned MIP models
- Slightly infeasible integer variables
- Running out of memory
- Difficulty solving subproblems: overcoming degeneracy
- Unsatisfactory optimization of subproblems
- Examples: optimizing a simple MIP problem
- Example: reading a MIP problem from a file
- Chapter 17. Solving mixed integer programming problems with quadratic terms
- Chapter 18. Benders algorithm
- Chapter 19. Solution pool: generating and keeping multiple solutions
- What is the solution pool?
- Example: simple facility location problem
- Filling the solution pool
- Accumulating incumbents in the solution pool
- Populating the solution pool
- Choosing whether to accumulate or populate
- Enumerating all solutions
- Impact of change on the solution pool
- Examining the solution pool
- Accessing a solution in the solution pool
- Using solutions from the solution pool
- Deleting solutions from the solution pool
- The incumbent and the solution pool
- Parameters of the solution pool
- Filtering the solution pool
- Chapter 20. Using special ordered sets (SOS)
- Chapter 21. Using semi-continuous variables: a rates example
- Chapter 22. Using piecewise linear functions in optimization: a transport example
- What is a piecewise linear function?
- Syntax of piecewise linear functions
- Discontinuous piecewise linear functions
- Isolated points in piecewise linear functions
- Using IloPiecewiseLinear in expressions
- Describing the problem
- Developing a model
- Solving the problem
- Displaying a solution
- Ending the application
- Complete program: transport.cpp
- Chapter 23. Indicator constraints in optimization
- Chapter 24. Logical constraints in optimization
- Chapter 25. Using logical constraints: Food Manufacture 2
- Chapter 26. Using column generation: a cutting stock example
- Chapter 27. Early tardy scheduling
- Part 5. Parallel optimization
- Chapter 28. Multithreaded parallel optimizers
- What are multithreaded parallel optimizers?
- Threads
- Determinism of results
- Using parallel optimizers in the Interactive Optimizer
- Using parallel optimizers in the Component Libraries
- Using the parallel barrier optimizer
- Concurrent optimizer in parallel
- Determinism, parallelism, and optimization limits
- Parallel MIP optimizer
- Clock settings and time measurement
- Chapter 29. Remote object for distributed parallel optimization
- CPLEX remote object for distributed parallel optimization
- Application layout for the remote object
- Programming paradigm in C for the CPLEX remote object
- More about CPXXopenCPLEXremote
- Programming in C++ with the CPLEX remote object
- Programming in Java with the CPLEX remote object
- Transport types for the remote object
- Contrasting local and remote environments and libraries
- Multicast: invoking the same methods on a group of objects
- Asynchronous execution
- User functions to run user-defined code on the remote machine
- Serializing for the remote object
- Sending status messages to the master
- Example: distributed concurrent MIP
- Code running on the master
- Creating and initializing a remote object
- Dispatching problem data to remote objects
- Destroying remote objects
- Setting parameters in remote objects
- Solving a problem with remote objects
- Fetching the results of distributed concurrent MIP optimization
- Processing status updates and receiving informational messages
- Setting up status updates on the remote machines: user functions
- Code running on the remote worker machines
- Deploying an application of the CPLEX remote object
- Example: parallel optimization of a Benders decomposition
- Chapter 30. Solving a MIP with distributed parallel optimization
- Distributed optimization of MIPs: the algorithm
- Special characteristics of distributed branch and bound
- Technical limits of distributed branch and bound
- VMC file for specifying parameters, ramp up options, and environment variables in distributed parallel optimization
- Before you begin
- Distributed parallel MIP in the Interactive Optimizer
- Using Open MPI with distributed parallel MIP
- Using MPICH with distributed parallel MIP
- Using a process transport protocol with distributed parallel MIP
- Using TCP/IP as the transport protocol with distributed parallel MIP
- Example: Callable Library (C API)
- Example: C++ API
- Example: Java API
- Example: Python API
- Using multiple processes as workers on a single machine
- Part 6. Infeasibility and unboundedness
- Chapter 31. Preprocessing and feasibility
- Chapter 32. Managing unboundedness
- Chapter 33. Diagnosing infeasibility by refining conflicts
- What is a conflict?
- What a conflict is not
- How to invoke the conflict refiner
- How a conflict differs from an IIS
- Meet the conflict refiner in the Interactive Optimizer
- Interpreting conflict
- More about the conflict refiner
- Refining a conflict in a MIP start
- Using the conflict refiner in an application
- Comparing a conflict application to Interactive Optimizer
- Chapter 34. Repairing infeasibilities with FeasOpt
- Part 7. Advanced programming techniques
- Chapter 35. User-cut and lazy-constraint pools
- What are user cuts and lazy constraints?
- What are pools of user cuts or lazy constraints?
- Differences between user cuts and lazy constraints
- Identifying candidate constraints for lazy constraint pool
- Limitations on user-cut pools
- Adding user cuts and lazy constraints
- Deleting user cuts and lazy constraints
- Chapter 36. Using goals
- Chapter 37. Using optimization callbacks
- What are callbacks?
- Informational callbacks
- Query or diagnostic callbacks
- Control callbacks
- Implementing callbacks with Concert Technology
- Example: deriving the simplex callback ilolpex4.cpp
- Implementing callbacks in the Callable Library
- Example: using callbacks lpex4.c
- Example: controlling cuts iloadmipex5.cpp
- Interaction between callbacks and parallel optimizers
- Return values for callbacks
- Terminating without callbacks
- Chapter 38. Goals and callbacks: a comparison
- Chapter 39. Advanced presolve routines
- Chapter 40. Advanced MIP control interface
- Part 8. Appendixes
- Acknowledgment of use: dtoa routine of the gdtoa package
- Further acknowledgments: AMPL
- Index