 Xpress Mosel examples
 Models by problem type / modeling tasks
 Folio  Modelling examples from 'Getting started'
LP, MIP and QP models, data input/output, user graphs, heuristics  Folio  Advanced modelling and solving tasks
Multiple MIP solutions, infeasibility handling, data transfer in memory, remote execution, XML and JSON data formats, solver tuning  Linearizations and approximations via SOS and piecewise linear (pwlin) expressions
Piecewise linear, approximation, SOS, SOS1, SOS2, SOS1, SOS2, Special Ordered Set, pwlin, pws, step function, piecewise linear function  General constraints and Boolean variables
general constraints, boolvar, logctr, Boolean variables, logical expressions, minimum value, maximum value, absolute value  Indicator constraints
indicator constraints, logic constraints, logctr  Assignment
simple LP problem, graphical representation of results  Bin packing
simple MIP problem, random generation of data,
use of model parameters, setting Optimizer controls  Blending ores
simple LP problem, formulation of blending constraints  Capital budgeting
simple MIP problem  Contract allocation
simple MIP problem, semicontinuous variables,
graphical representation of results  Cutting stock
MIP problem solved by column generation,
working with multiple problems, using 'sethidden',
setting Optimizer and Mosel control parameters  Lot sizing
MIP problem, implementation of BranchandCut and
CutandBranch algorithms, definition of Optimizer callbacks,
Optimizer and Mosel parameter settings, 'case', 'procedure',
'function', time measurement  Facility location
MIP problem, graphical solution representation,
resolving with modified bounds, data input from file,
dynamic arrays for data and decision variables, use of
'exists', model cuts  Knapsack
simple IP problem, formulation of knapsack constraints,
model parameters, function 'random'  Multiperiod, multisite production planning
LP or MIP problem, formulation of resource constraints and
material balance constraints, formatted solution printing, ifthenelse, ifthenelif statements  Project planning with resource constraints
MIP problem, alternative formulation with SOS1,
tricky formulation of resource use profiles and
calculation of benefits, graphical solution representation  Purchasing with price breaks
MIP problem, modeling a piecewise linear function with SOS2,
graphical representation of data  Transport
simple LP problem, using dynamic arrays for data and
decision variables, formatted output printing, inline 'if',
format of data files  TSP
MIP problem, loop over problem solving, TSP subtour
elimination algorithm;
procedure for generating additional constraints, recursive
subroutine calls, working with sets, 'foralldo',
'repeatuntil', 'getsize', 'not', graphical representation
of solutions  Set covering
MIP problem, modeling an equivalence; sparse data format,
graphical output representation, 'ifthenelse'  Single period product mix
Simple LP problem, single period production planning  Personnel requirement planning
simple MIP problem, formulation of balance constraints
using inline 'if'  Matching flight crews
2 MIP problems with different objectives, data preprocessing,
incremental definition of data array, encoding of arcs,
logical 'or' (cumulative version) and 'and', 'procedure'
for printing solution, 'foralldo', 'max', 'finalize',
graphical representation of results, 'sin', 'cos'  Maximum flow in a telecom network
MIP problem, encoding of arcs, 'range', 'exists', 'create',
algorithm for printing paths, 'foralldo', 'whiledo',
'round', graphical representation of results  Multicommodity network flow
MIP problem, encoding of paths, 'finalize', 'getsize'  Vehicle routing
MIP problem, formulation of constraints to eliminate
inadmissible subtours, definition of model cuts,
selection with '', algorithm for printing the tours,
graphical solution representation  Minimum cost flow
MIP problem, formulation with extra nodes for modes of
transport; encoding of arcs, 'finalize', union of sets,
nodes labeled with strings, graphical solution representation  Line balancing
MIP problem, encoding of arcs, 'range', formulation of
sequencing constraints  Minimum weight spanning tree
MIP problem, formulation of constraints to exclude subcycles,
graphical representation of results  Flowshop scheduling
MIP problem, alternative formulation using SOS1,
graphical solution representation  Job shop scheduling
MIP problem, formulating disjunctions (BigM);
'dynamic array', 'range', 'exists', 'foralldo',
graphical solution representation  Transshipment formulation of multiperiod production planning
MIP problem, representation of multiperiod production
as flow; encoding of arcs, 'exists', 'create', 'isodd',
'getlast', inline 'if'  Set partitioning
MIP problem, algorithm for data preprocessing; file
inclusion, 3 nested/recursive procedures, working with
sets, 'ifthen', 'foralldo', 'exists', 'finalize'  Open shop scheduling
MIP problem, data preprocessing, algorithm for preemptive
scheduling that involves looping over optimization,
''Gantt chart'' printing and drawing  Sequencing jobs on a single machine
MIP problem with 3 different objectives; 'procedure'
for solution printing, 'ifthen'  Timetable for courses and teachers
MIP problem, many specific constraints, tricky (pseudo)
objective function, 'finalize'  Basic LP tasks: problem statement and solving; solution analysis
LP solving, solution printout, array and set data structures  Basic MIP tasks: binary variables; logic constraints
MIP solving, binary variables, index set types, logic constraints  LCSP: Labour constrained scheduling problem
Dynamic creation of variables, formulation of resource constraints  Transportation problem with piecewise linear cost expressions
MIP problem  Approximating nonlinear univariate functions via piecewise linear constraints
MIP problem  MAXSAT solving via MIP
MAXSAT model  Conditional creation of decision variables
use of 'exists', finalization of index sets  Delivery: Infeasibility analysis with IIS
Retrieving and displaying IIS  Overview of Mosel examples for 'Business Optimization' book
LP, MIP, NLP problem formulations, solution reporting, graphical display, multiple problems, iterative solution algorithms
 Models by application area
 Introductory examples
 Mining and process industries
 Scheduling problems
 Planning problems
 Loading and cutting problems
 Ground transport
 Air transport
 Telecommunication problems
 Economics and finance
 Timetabling and personnel planning
 Local authorities and public services
 Programming with Mosel
 Dynamic package loading
dynamic package loading, model compilation, BIM file  Recursive remote files
Access to files on remote (parent or
child) nodes  Basic set operations
Initializing sets, set operations, set comparison  Using moseldoc
Generating online documentation for Mosel models and packages  Largest common divisor
Recursive function calls; using 'readln'  Smallest and largest value in a set
The 'ifthenelifthen' selection statement  Perfect numbers
Using the 'forall' loop  Prime numbers using the Sieve of Eratosthenes
Nested loops: repeatuntil, while, whiledo  Read two tables and a set from a text data file
File access, using 'readln', 'fskipline'  Parsing a CSVformat data file
Text parsing functionality  Sort an array of numbers using Shell's method
Nested loops: repeatuntil, foralldo, whiledo  Sort an array of numbers using Quicksort
Recursive subroutine calls, overloading of subroutines  Defining a package to handle binary trees
Definition of subroutines, data structures list and record, type definition  Encapsulate binary file into a BIM
Submodel included in model source, datablock, deployment as executable  Generate an executable from a Mosel source file
deployment as executable, deployment via scripts  Using the automatic translation system
Using xprnls, generating dictionary files  Debugging models via the Remote Invocation Protocol
Remote model execution in debugging mode, implementation of a debugger  Profiling and code coverage via the Remote Invocation Protocol
Remote model execution in profiling mode, decoding of profiling and coverage results  Creating and saving XML documents
Simple access routines  adding nodes, recursive display of subtrees  Using XMLformat files as databases
Retrieving XML nodes using xpath search expressions; modifying and formatting XML files  Parsing XML and JSON documents
Parsing documents with unknown structure  Converting WCNF to Mosel format
Processing a text file into a different text format, generating Mosel code, deployment as executable  Defining a package to read JSON documents of unknown structure
Definition of subroutines, data structures of union types, type definition, JSON parsing  Error handling
handling I/O errors during data input  Using counters
Using and combining 'count' and 'as counter'  Local declarations in with statements
Local declaration of entities, array aliasing  Working with arrays
array initialization, indexation, sparse array, array dimensions, array size  Working with lists
Lists: initialization, enumeration, operators, access functions  Eulerian circuit  working with lists
list operators, list handling routines  Working with records
Defining and initializing records  Definition of a network
Working with record data structures  User type definition
Defining a user type with a record  Working with unions
defining unions, type any, specifying union type, initialization of unions from/to text format files, reference to operator  Subroutines
Subroutine definition, overloading, recursive function calls, function return values, variable number of arguments, subroutine references, mmreflect  Output formatting
real number format, text formatting  Using the debugger and profiler
Debugging and profiling commands, parallel debugging  Checking memory usage
Using sparse arrays, dynamic array, ahsmap array  Writing packages: definition of constant symbols, subroutines, types, and parameters
Implementing subroutines, overloading, using packages  Namespace definition
Implementing packages, defining namespaces, namespace search, namespace groups  Package version management
Implementing packages, version management, deprecation, annotations  Text handling and regular expressions
Types 'text', 'textarea', 'parsectx'; text parsing  Defining and retrieving annotations
Accessing annotations from a model or host application  Using documentation annotations
Using documentation annotations, moseldoc tool  Using 'exists' for loops over sparse arrays
Enumeration of sparse data, exists  Parameters: tolerances
Comparison tolerance  Using the model return value for error handling
Model exit code  Preprocessing Mosel code
Preprocessing source code, preprocessor symbol, positioning markers
 Solving techniques
 Using the AEC2 package with mmjobs
Find or start AEC2 instance, start Mosel, model execution  Column generation for a cutting stock problem
Variable creation, using 'sethidden', working with multiple problems  Cut generation for an economic lotsizing (ELS) problem
Adding constraints and cuts, using the cut manager, runtime parameters  Binary fixing heuristic for the Coco problem
Working with bases, saving and loading MIP solutions  BranchandPrice for the Generalized Assignment Problem
Working with submodels, record data structures  Preemptive and Archimedian goal programming
Changing constraint type, redefining the objective  Using multiobjective solving
Multiple objectives, configuration of objectives  Successive linear programming (SLP) model for a financial planning problem
Redefinition of constraints  Output formatting for a transportation model
Dynamic arrays for data and decision variables, formatting output  Solving an optimization problem via nlsolv
Using module nlsolv  Cutandbranch and branchandcut
Using the optnode callback or the cut manager callback, addcuts, storecuts and loadcuts, subroutine reference  Hybrid MIPCP problem solving: sequential solving
Solving a sequence of CP subproblems, inmemory data exchange  Hybrid MIPCP problem solving: concurrent solving
Parallel and sequential solving of subproblems  MIP start solutions and subtour elimination algorithm for the traveling salesman problem (TSP)
CP target values, MIP start solution, MIP callbacks, cutting plane algorithm  Working with multiple models: submodels, coordination, communication, and parallelization
Parallel computing, distributed computing, distributed architecture, inmemory data exchange, shmem, job queue, events, detach submodel, clone submodel  DantzigWolfe decomposition: combining sequential and parallel solving
Concurrent subproblem solving, coordination via events, inmemory data exchange, mempipe, mempipe notifications, remote mempipe  Benders decomposition: sequential solving of several different submodels
Multiple concurrent submodels, events, inmemory data exchange  Jobshop scheduling  Generating start solutions via parallel computation
Sequential and parallel submodel execution, loading partial MIP start solutions, model cloning, shared data  Outer approximation for quadratic facility location: solving different problem types in sequence
Iterative sequential submodel solving, nonlinear subproblem, MIQP formulation  Solving the TSP problem by a series of optimization subproblems
Solution heuristic, parallel submodel execution  Looping over optimization runs (within a model, batch executions, and multiple models/submodel)
Multiple problem runs, submodel  Names handling for decision variables and constraints
Names generation, variable name, constraint name, location information, compilation options, loading names, public declaration  Using Optimizer Console for running matrices within Mosel
mmxprs command, Xpress Solver command line, running matrix file  Evolutionary algorithm for supply management
Evolutionary algorithm, iterative LP solving  Lagrangian Relaxation for a Generalized Assignment Problem
Working with subproblems, iterative LP solving  News Vendor Problem
2stage stochastic program, scenariobased robust optimization  Multistage stochastic portfolio investment
Iterative submodel runs, inmemory data exchange  Sludge production planning solved by recursion
Iterative solving, recursion, SLP
 Nonlinear optimization with Mosel
 Locate airport while minimizing average distance
quadratic constraints and objective  Maximise discount at a bookstore
Discrete variables  Nonlinear objective with integer decision variables
Discrete variables  Determine chain shape
Quadratic constraints  Facility location
Nonlinear objective  Approximation of a function
Approximation of a function  Maximal inscribing square
Trigonometric functions  Static load balancing in a computer network
Nonlinear objective  Minimum surface between boundaries
Nonlinear constraints and objective  Moon landing
Nonlinear objective and constraints  Polygon construction under constraints
Trigonometric constraints and objective  Portfolio optimization
Quadratic constraints and quadratic objective  Locating electrons on a conducting sphere
Nonlinear constraint and objective, alternative objective functions  Find the shape of a chain of springs
Quadratic constraints  Steiner tree problem
Quadratic constraints  Trafic equilibrium
Nonlinear objective  Modeling hang glider trajectory
Nonlinear constraints, trapezoidal discretization  Force required to lift an object
SOCP formulation  Convex hull of two triangles
Trigonometric constraints, graphical representation  Optimal number and distribution of grid points for a nonlinear function
Discretization, GNUPlot graphic, subroutine references  Nonlinear trimloss problem
NLP, alternative solvers
 Robust optimization with Mosel
 Introductory examples
Defining robust constraints, uncertainty sets, nominal values  Robust formulations of the single knapsack problem
Types of uncertainty sets  Robust portfolio optimization
'ellipsoid' uncertainty set, retrieving the worst value of an uncertain  Security constrained robust unit commitment
'scenario' and 'cardinality' uncertainty sets  Production planning under demand uncertainty
'scenario' and polyhedral uncertainty sets  Production planning under energy supply uncertainty
polyhedral uncertainty set  Robust shortest path
'cardinality' uncertainty set  Robust network optimization for VPN design
polyhedral uncertainty set
 Data handling ( ODBC/SQL, sparse data, I/O drivers, Spreadsheets )
 Energyforecast  regression analysis with R
Regression analysis, data exchange with R, evaluating R functions from Mosel  Logistic regression on flight delay data using R
Logistic regression, data exchange with R, evaluating R functions from Mosel, graph drawing with R  Blend  data input from external sources
Accessing data sources (text, spreadsheets, databases)  Output of expressions
Using 'initializations to' with 'evaluation of'  Transport  data formats for online use
XML and JSON data formats, generation of HTML  Reading sparse data from text files, spreadsheets and databases, and from memory
Data input, initializations from, SQL, ODBC, spreadsheet, CSV  Data output to text files, spreadsheets and databases, and to memory
Data output, initializations to, SQL, ODBC, spreadsheets, CSV  Dataframe formats
dataframe, union types, CSV format  Dense vs. sparse data format
array types, noindex  Autoindexation for singledimensional arrays
autoindexation  Writing out solution values to text files, spreadsheets or databases
solution data output, 'evaluation of'  Spreadsheets and databases: working with multiple data tables and arrays
data input/output, multiple tables, multiple data arrays  Formulation of SQL (selection) statements
Advanced SQL functionality, retrieve database and table structure  Reading and writing records and lists
record data structure, list data structure  Reading and writing union types
Types any, date, time; data input/output  Reading and writing dates and times
data types date, time, datetime  Reading 3dimensional arrays
Multidimensional array input, option partndx  Burglar  Data source access from Mosel models
'mmodbc.odbc', 'mmsheet.excel', 'mmetc.diskdata' I/O drivers, SQL, XML, JSON  Burglar  Inmemory data exchange between Mosel models
'bin', 'shmem', 'raw', 'text', 'tmp', 'rmt' I/O drivers
 Graphing examples
 Mandelbrot
Queued execution of remote models with result
graphic  Drawing results of multiple optimization runs
Iterating over MIP solves, graphical representation of solution values  Drawing line fractals
Lines with simple styling, recursive subroutine calls  Drawing line plots
Points and polylines with various styling options  Drawing a bar chart
Graphical objects rectangle and text, simple styling  Drawing a pie chart
Graphical objects pie and text, simple styling  Drawing a Gantt chart
Graphical objects rectangle and text, simple styling, reading freeformat input text data file, animation  Iterative display of tours
Points and polylines, pausing display, intercepting window closing, animation, image inclusion  Display matrix scaling information
Retrieving matrix coefficient ranging information, getscale, SVG graph drawing
 Distributed calculation and remote invocation
 Using the AEC2 package with XPRD
Find or start AEC2 instance, start Mosel, model execution  Reading and writing data using the 'bin:' format
Binary data format  Implementing a file manager
Remote model execution, file manager, events  Approximating PI number
Remote execution of multiple Mosel models  Runprime  Remote model execution
Remote model execution, data exchange between remote nodes  Basic tasks: remote connection, coordination, communication, and parallelization
Distributed computing, concurrent submodel execution, job queue, events  ELS  Solving several model instances in parallel
Parallel execution of submodels, parallel execution of submodels, stopping submodels  Mandelbrot  Java GUI for distributed computation with Mosel
Parallel execution of submodels, Java solution graph  Folio  remote execution of optimization models
Submodel execution, events, bindrv binary format, inmemory data I/O
 C Library examples
 Folio  Embedding examples from 'Getting started'
Model compilation, parameterized model execution, matrix output, accessing results  Compiling a model file into a BIM file
Model compilation  Retrieving data from a Mosel model
Accessing sets, arrays, lists, records; retrieving solution information  Working with models and accessing dynamic libraries in Mosel
Display information and contents of models and libraries  Interrupting a running model using CtrlC
Stopping a model run  Data input/output via I/O drivers
Compilation to/from memory; data input/output in memory; redirect output using the 'cb' driver  Implementing a source coverage testing tool
Using the debugger interface  Basic embedding tasks
Compile/load/run models, retrieve information about model objects, redirect model output  Inmemory data exchange
Data exchange during model execution  Switching to solving with Xpress Optimizer
Using the Xpress Optimizer library with Mosel  Compilation to/from memory
Using the 'mem' I/O driver  Burglar  Exchange of information with embedded models
'cb', 'bin', 'mem', 'raw', 'sysfd' I/O drivers
 Java Library examples
 Folio  Embedding examples from 'Getting started'
Model compilation, parameterized model execution, matrix output, accessing results  Retrieving data from a Mosel model
Accessing sets, arrays, lists, records; retrieving solution information  Working with models and accessing dynamic libraries in Mosel
Display information and contents of models and libraries  Data input/output via I/O drivers
Compilation to/from memory; data input/output in memory; redirect output using the 'java' driver  Implementing a source coverage testing tool
Using the debugger interface  Basic embedding tasks
Compile/load/run models, retrieve information about model objects, redirect model output  Inmemory data exchange
Data exchange during model execution  Compilation to/from memory
Using the 'java' I/O driver
 VBA Library examples
 Folio  Embedding examples from 'Getting started'
Model compilation, parameterized model execution  Folio  Embedding examples from 'Getting started'
Parameterized model execution, data exchange in memory  Launching Mosel from Excel using VBA
LP solving, start Mosel from a VBA script in Excel, data input from Excel  Start/stopping Mosel from Excel and capturing output
MIP solving, start and interrupt Mosel from a VBA script in Excel, Mosel output to Excel  Basic embedding tasks
Compile/load/run models, redirect model output
 C#.NET Library examples
 Folio  Embedding examples from 'Getting started'
Model compilation, parameterized model execution, matrix output, accessing results  Retrieving data from a Mosel model
Accessing sets, arrays, lists, records; retrieving solution information  Working with models and accessing dynamic libraries in Mosel
Display information and contents of models and libraries  Data input/output via I/O drivers
Compilation to/from memory; data input/output in memory  Basic embedding tasks
Compile/load/run models, retrieve information about model objects, redirect model output  Inmemory data exchange
Data exchange during model execution  Compilation to/from memory
Using C#
 VB.NET Library examples
 Working with models, data and dynamic libraries in Mosel
Accessing sets and arrays; retrieving solution information; displaying information and contents of models and libraries; Compilation to/from memory; data input/output in memory
 Writing Mosel modules
 Definition of constants of different types
Defining integer, real, string, boolean constants  Definition of a procedure for getting solution values into an array
Implementing a subroutine  Definition of complex numbers and operators to work with them
Defining an external type with operators  Definition of type 'task' and subroutines for accessing it
Defining an external type with operators and access routines; defining module parameters and services  Definition of type 'date' and subroutines for accessing it
Defining an external type with operators and access routines; defining module parameters and services  Definition of three new types and operators to work with them
Defining external types with operators  Basic LP/MIP solver interface for Xpress Optimizer
Using the NI matrix handling functionality, extending a type, defining parameters and subroutines, defining a callback function  Basic QCQP solver interface for Xpress Optimizer
Using the mmnl matrix handling functionality, extending a type, defining parameters and subroutines, defining a callback function  Declaring a static module
Module embedded in a C program  Using the 'zlib' library to provide IO driver 'compress' functionality
Defining I/O drivers  Module implementing driver 'toC' to save the compilation result to a C file
Defining an I/O driver  How best to debug a module
Creating a static module
 Calling static Java methods from Mosel
 Passing single values from a Mosel model to a Java method
 Passing an array from a Mosel model to a Java method
 Returning an object from a Java method
 Handling exceptions thrown by a Java method called from a Mosel model
 Calling Python 3 from Mosel
 Portfolio optimization using pandas to calculate covariance
 Invert a Mosel matrix with NumPy
 Python I/O driver example
 Puzzles and Recreational Mathematics
 Sudoku (CP and MIP models)
Using 'all_different', enumerating all feasible solutions, SVG graphs showing progress of solving  Futoshiki (CP and MIP models)
Using 'all_different', formatted solution printout  Fantasy OR: Sangraal (CP and MIP models)
Formulation of a scheduling problem with MIP and CP  Fiveleaper (MIP model and graphics)
Subtour elimination algorithm  Puzzles and pastimes from the book `Programmation Lineaire'
MIP and CP formulations for discrete feasibility problems
 Xpress Optimizer examples
 Calling the Optimizer library from C
 Folio  Introductory examples from 'Getting Started'
LP, MIP and QP models, explicit initialization, index sets, heuristic solution  The travelling salesman problem
Using Xpress callbacks  Branching rule branching on the most violated Integer/Binary
Using the change branch callbacks  Apply a binary fixing heuristic to an unpresolved MIP problem
Changing bounds, accessing solver controls  Perform objective function parametrics on a MIP problem
Saving/loading bases, changing objective coefficients  Perform RHS parametrics on a MIP problem
Changing RHS coefficients, working with bases  Apply a primal heuristic to a knapsack problem
Using the MIP log callback  Apply an integer fixing heuristic to a MIP problem
Changing bounds  Load an LP and modify it by adding an extra constraint
Load LP problem, adding a constraint  Save/access a postsolved solution in memory
Retrieving solution values and tree search information  Adding MIP solutions to the Optimizer
Using the optnode callback, saving/loading bases, changing bounds  Solve LP, displaying the initial and optimal tableau
Retrieve basic variables and their names, btran  Modify problem: add an extra variable within an additional constraint
Adding rows and columns, branching directives  10 best solutions with the MIP solution enumerator
Using the solution enumerator and MIP solution pool  Collecting all solutions with the MIP solution pool
Using the solution enumerator and MIP solution pool  Repairing infeasibility
Using repairinfeas  Goal programming
Lexicographic goal programming using the Xpress multiobjective API
 Calling the Optimizer library from C++
 Linearizations and approximations via SOS and piecewise linear (pwl) expressions
Piecewise linear, approximation, SOS, SOS1, SOS2, SOS1, SOS2, Special Ordered Set, piecewise linear function  General constraints
general constraints, minimum value, maximum value, absolute value  Indicator constraints
indicator constraints, logic constraints  Burglar  Formulating logical constraints
MIP, indicator constraints  Constraint types  Logical, general, SOS, quadratic
Defining different types of constraints  Boxes  Nonlinear constraints
Nonlinear constraints  Capital budgeting  Using multiobjective optimization
Multiobjective solving  Catenary  Solving a QCQP
Stating quadratic constraints  Contract  Semicontinuous variables
Defining semicontinuous variables  Cutstk  Column generation for a cutting stock problem
Working with subproblems, modifying constraints  The travelling salesman problem
Using Xpress callbacks
 Calling the Optimizer library from Java
 Burglar  Formulating logical constraints
MIP, indicator constraints  Constraint types  Logical, general, SOS, quadratic
Defining different types of constraints  Boxes  Nonlinear constraints
Nonlinear constraints  Capital budgeting  Using multiobjective optimization
Multiobjective solving  Catenary  Solving a QCQP
Stating quadratic constraints  Contract  Semicontinuous variables
Defining semicontinuous variables  Cutstk  Column generation for a cutting stock problem
Working with subproblems, modifying constraints  Els  An economic lotsizing problem solved by cutandbranch and branchandcut heuristics
Looping of optimization, using the cut manager  Facility location problem  Data as arrays or collections
Data structures arrays and collections  Folio  Examples from 'Getting Started'
MIP modeling, binary fixing heuristic, quadratic constraints, infeasibility handling  General constraints  Minimium value and absolute value
Minimum value constraints and absolute value constraints  Hang glider trajectory
Nonlinear constraints, trapezoidal discretization  Multiknapsack  Constraint formulation alternatives
Constraint formulation options  Multi problems  Modifying constraint and variable definitions
Constraint redefinition, multiple problems  Polygon  Defining nonlinear constraints
Nonlinear constraints  Project planning  Defining SOS
Binary variables, SOS definition  Multiperiod, multisite production planning
Formulation of resource constraints and
material balance constraints  Purchase  Definition of SOS2
Defining SOS2, pwl, piecewise linear  Solving a nonlinear problem by recursion
Iterative solving, modify constraint definitions  Sangraal  Scheduling problem with indicator constraints
Formulation of a scheduling problem with indicator constraints  Wagon  MIP start solution heuristic
Loading a MIP start solution  Adding the message callback in Java
Using the message callback  Irreducible Infeasible Set Search
Using IIS  10 best solutions with the MIP solution enumerator
Using the solution enumerator and MIP solution pool  Collecting all solutions with the MIP solution pool
Using the solution enumerator and MIP solution pool  Collecting all solutions with the MIP solution pool
Modify a problem by adding extra rows and columns  Goal programming
Lexicographic goal programming using the Xpress multiobjective API  The travelling salesman problem
Using Xpress callbacks  Apply a binary fixing heuristic to an unpresolved MIP problem
Changing bounds, accessing solver controls  Apply a primal heuristic to a knapsack problem
Using the MIP log callback  Load an LP and modify it by adding an extra constraint
Load LP problem, adding a constraint  Save/access a postsolved solution in memory
Retrieving solution values and tree search information  Adding MIP solutions to the Optimizer
Using the optnode callback, saving/loading bases, changing bounds  Solve LP, displaying the initial and optimal tableau
Retrieve basic variables and their names, btran  Branching rule branching on the most violated Integer/Binary
Using the change branch callbacks  Repairing infeasibility
Using repairinfeas  Apply an integer fixing heuristic to a MIP problem
Changing bounds  Perform objective function parametrics on a MIP problem
Saving/loading bases, changing the objective  Perform RHS parametrics on a MIP problem
Saving/loading bases, changing righthand side values
 Calling the Optimizer library from C#.NET
 Burglar  Formulating logical constraints
MIP, indicator constraints  Constraint types  Logical, general, SOS, quadratic
Defining different types of constraints  Capital budgeting  Using multiobjective optimization
Multiobjective solving  Catenary  Solving a QCQP
Stating quadratic constraints  Contract  Semicontinuous variables
Defining semicontinuous variables  Cutstk  Column generation for a cutting stock problem
Working with subproblems, modifying constraints  Els  An economic lotsizing problem solved by cutandbranch and branchandcut heuristics
Looping of optimization, using the cut manager  Facility location problem  Data as collections
Collections data structure  Folio  Examples from 'Getting Started'
MIP modeling, binary fixing heuristic, quadratic constraints, infeasibility handling  Multiknapsack  Constraint formulation alternatives
Constraint formulation options  Polygon  Defining nonlinear constraints
Nonlinear constraints  Project planning  Defining SOS
Binary variables, SOS definition  Multiperiod, multisite production planning
Formulation of resource constraints and
material balance constraints  Purchase  Definition of SOS2
Defining SOS2, pwl, piecewise linear constarints  Solving a nonlinear problem by recursion
Iterative solving, modify constraint definitions  Wagon  MIP start solution heuristic
Loading a MIP start solution  The travelling salesman problem
Using Xpress callbacks  Apply a binary fixing heuristic to an unpresolved MIP problem
Changing bounds, accessing solver controls  Irreducible Infeasible Set Search
Using IIS  Apply a primal heuristic to a knapsack problem
Using the MIP log callback  Load an LP and modify it by adding an extra constraint
Load LP problem, adding a constraint  10 best solutions with the MIP solution enumerator
Using the solution enumerator and MIP solution pool  Collecting all solutions with the MIP solution pool
Using the solution enumerator and MIP solution pool  Save/access a postsolved solution in memory
Retrieving solution values and tree search information  Goal programming
Lexicographic goal programming using the Xpress multiobjective API
 Calling the Optimizer library from VB.NET
 Apply a binary fixing heuristic to an unpresolved MIP problem
Changing bounds, accessing solver controls  Irreducible Infeasible Set Search
Using IIS  Apply a primal heuristic to a knapsack problem
Using the MIP log callback  Load an LP and modify it by adding an extra constraint
Load LP problem, adding a constraint  10 best solutions with the MIP solution enumerator
Using the solution enumerator and MIP solution pool  Collecting all solutions with the MIP solution pool
Using the solution enumerator and MIP solution pool  Save/access a postsolved solution in memory
Retrieving solution values and tree search information
 Xpress NonLinear examples
 Nonlinear C library examples
 Maximizing the area of a polygon using tokens based input
Using token lists to express nonlinear formulas  Maximizing the area of a polygon using string based input
Using string based formulas to express nonlinear formulas  Providing initial values
Providing initial values to nonlinear variables  Implementing user functions returning their own derivatives
Implementing complex user functions returning their own derivatives  Implementing the polygon examples as a black box function
Implementing user functions  Maximizing the area of a polygon using tokens based input  using a 'map' userfunction
Using strings to express nonlinear formulas, including a 'map' userfunction  Maximizing the area of a polygon using tokens based input  using a 'vecmap' userfunction
Using strings to express nonlinear formulas, including a 'vecmap' userfunction  Maximizing the area of a polygon using tokens based input  using a 'multimap' userfunction
Using strings to express nonlinear formulas, including a 'multimap' userfunction  Maximizing the area of a polygon using tokens based input  using a 'mapdelta' userfunction
Using strings to express nonlinear formulas, including a 'mapdelta' userfunction  Maximizing the area of a polygon using tokens based input  using a 'vecmapdelta' userfunction
Using strings to express nonlinear formulas, including a 'vecmapdelta' userfunction  Maximizing the area of a polygon using tokens based input  using a 'multimapdelta' userfunction
Using strings to express nonlinear formulas, including a 'multimapdelta' userfunction
 Calling the Nonlinear library from C#.NET
 Maximizing the area of a polygon
Using strings to express nonlinear formulas  Maximizing the area of a polygon using a 'map' userfunction
Using strings to express nonlinear formulas, including a 'map' userfunction  Maximizing the area of a polygon using a 'vecmap' userfunction
Using strings to express nonlinear formulas, including a 'vecmap' userfunction  Maximizing the area of a polygon using a 'vecmapdelta' userfunction
Using strings to express nonlinear formulas, including a 'vecmapdelta' userfunction  Maximizing the area of a polygon using a 'mapdelta' userfunction
Using strings to express nonlinear formulas, including a 'mapdelta' userfunction  Maximizing the area of a polygon using a 'multimap' userfunction
Using strings to express nonlinear formulas, including a 'multimap' userfunction  Maximizing the area of a polygon using a 'multimapdelta' userfunction
Using strings to express nonlinear formulas, including a 'multimapdelta' userfunction
 Calling the Nonlinear library from Java
 Maximizing the area of a polygon
Using strings to express nonlinear formulas  Maximizing the area of a polygon using a 'map' userfunction
Using strings to express nonlinear formulas, including a 'map' userfunction  Maximizing the area of a polygon using a 'vecmap' userfunction
Using strings to express nonlinear formulas, including a 'vecmap' userfunction  Maximizing the area of a polygon using a 'vecmapdelta' userfunction
Using strings to express nonlinear formulas, including a 'vecmapdelta' userfunction  Maximizing the area of a polygon using a 'mapdelta' userfunction
Using strings to express nonlinear formulas, including a 'mapdelta' userfunction  Maximizing the area of a polygon using a 'multimap' userfunction
Using strings to express nonlinear formulas, including a 'multimap' userfunction  Maximizing the area of a polygon using a 'multimapdelta' userfunction
Using strings to express nonlinear formulas, including a 'multimapdelta' userfunction
 Mosel examples of the Xpress NonLinear manual
 Effects of convexity
Convexity  Partial derivatives
Numerical differentiaton  Local solutions
Local optimality  Dual multipliers
Dual multipliers  Nonconnected feasible region
Nonconnected feasible regions  Feasiblity breakers \ penalty error vectors
Feasiblity breakers  Error costs and penalty multipliers
Penalty multipliers  Solution support sets
Support sets  Step bounding
Step bounding  Zero placeholders
Zero placeholders
 Xpress Python examples
 Python examples solving problems using the Xpress Solver
 Linearizations and approximations via SOS and piecewise linear (pwl) expressions
Piecewise linear, approximation, SOS, SOS1, SOS2, SOS1, SOS2, Special Ordered Set, piecewise linear function  General constraints
general constraints, minimum value, maximum value, absolute value  Indicator constraints
indicator constraints, logic constraints  Using NumPy arrays to create variables
Using NumPy arrays  Visualize the BB tree
Using the newnode callback  Irreducible Infeasible Sets
Using Irreducible Infeasible Sets  Loading a problem
Loading a problem directly  Using Python model objects to build a problem
Modelling using Python objects  Changing the optimization problem
Changes to a problem  Extending a problem
Extending a problem  Using NumPy and Xpress
Using NumPy and Xpress  Finding an LP subsystem with as many constraints as possible
 Basis and Stability
Basis handling and sensitivity methods  Solving a quadratically constrained problem
Building quadratic expressions  Solving a nonconvex quadratic problem
Building quadratic expressions  Solving a quadratically problem
Building quadratic expressions  Repeatedly solving a problem
Solving a problem multiple times  Using indicators
Model with indicators  Using special ordered sets
Model with special ordered sets  The travelling salesman problem
Using Xpress callbacks  Solving a TSP using NumPy
Using Xpress callbacks  Writing and reading problem files
Writing and reading a problem to disk  The feasiblity pump
Writing and reading a problem to disk  Knapsack problem
MIP problem with binary variables  The nqueens problem
Puzzle modeling  Mincostflow problem
Modelling a graph problem  Solving Sudoku
Puzzle modeling  Comparing Matrices
Compare two optimization problems  Multicommodity flow problem
Solve a multicommodity flow minimum cost optimization problem on a randomly created graph  Find largestarea inscribed polygon
 Read problem data into matrix and vectors
 Solve a nonconvex MIQCQP problem
 Solve a simple MIP using Benders decomposition
 Create a problem with piecewise linear functions
 Use the API to create a model with piecewise linear functions
 Create a problem with general constraints that use operator abs
 Create a problem with general constraints with the operator abs by using the API
 Create a problem with general constraints that use operator max
 Create a problem with general constraints with operator max by using the API
 Create a problem with logical constraints
 Create a problem with general constraints with logic operators by using the API
 Create an iterative algorithm cutting stock problem
 Maximize the sum of logistic curves subject to linear and piecewise linear constraints
 Transportation problem with piecewiselinear costs
 Modeling Satisfiability (SAT) problems with MIP
 Modeling PseudoBoolean Optimization problems with MIP
 Resolving problem using the Barrier method's warm start
 Using the tuner functions in the Python interface
 Multiobjective knapsack problem
Multiobjective MIP problem with binary variables  Goal programming
Lexicographic goal programming using the Xpress multiobjective API  Markowitz portfolio optimization
Multiobjective quadratic optimization  Basic LP tasks: problem statement and solving; solution analysis
LP solving, modeling variables and constraints, printing the solution  Network problem: transport from depots to customers
LP solving, modeling variables and constraints  Blend: A model for mineral blending
simple LP problem, formulation of blending constraints  Basic MIP tasks: binary variables; logic constraints
MIP solving, binary variables, index set types, logic constraints  Coco: The Coco productional planning problem
LP problem, formulation of resource constraints and
material balance constraints, formatted solution printing  Catenary: Determine chain shape
QCQP problem  Pplan: A project planning problem
Formulation of resource use profiles  Firestns: A setcovering model for emergency service provision
Solve a MIP problem  Solving a quadratically constrained problem
Solve a nonlinear problem  Solve a polynomial optimization problem
Modeling a polynomial optimization problem  Modeling with user functions
Modeling with user functions
 Xpress R Interface examples
 R examples solving problems using the Xpress Optimizer
 Load and solve a simple 2x2 linear program
xprs_loadproblemdata, displaying a solution as a data frame, a simple pipe workflow  Formulate and solve a Facility Location Problem
xprs_loadproblemdata, writeprob, setoutput, xprs_optimize, getsolution  Solve an LP and a MIP using XpressR
xprs_loadproblemdata, getintattrib, getdblattrib, readprob, getmipsol, getsolution  Read and write problems to and from standard formats MPS and LP
readprob, setintcontrol, writeprob  Set controls of Xpress
readprob, setintcontrol, setdefaultcontrol, getintattrib, getdblattrib, setdefaults, dumpcontrols  Query Attributes of Xpress
createprob, readprob, printing, getintattrib  Add indicator constraints
createprob, readprob, mipoptimize, getsolution, addrows, setindicator  Register an R function as callback into Xpress
readprob, getintattrib, addcboptnode, addcbintnode, getdblattrib  Formulate a quadratic optimization problem in Xpress
xprs_loadproblemdata, writeprob, xprs_optimize  Solving different types of Sudokus with the FICO Xpress Optimizer
xprs_loadproblemdata, addrows, getmipsol, mipoptimize  Modeling Sudokus creating columns and rows incrementally using xprs_newcol and xprs_addrow
createprob, setprobname, chgbounds, xprs_newcol, xprs_addrow, xprs_newrow, setoutput, getmipsol, mipoptimize  Solve Traveling Salesperson Problems using callbacks or delayed rows
xprs_loadproblemdata, addrows, addcuts, addcboptnode, addcbpreintsol, getcallbacksolution, loaddelayedrows  Solve a maximum flow problem and visualize the result
createprob, chgobjsense, setprobname, xprs_newcol, chgobj, xprs_addrow, getsolution  Solve a modified bin packing problem with the addition of a simple greedy heuristic
addmipsol, createprob, xprs_newcol, xprs_newrow, getsolution  Solve a routing problem using an arcpaths formulation for a telecommunication network
createprob, chgobjsense, xprs_newcol, xprs_addrow, getsolution  Solve a production planning problem
createprob, chgbounds, xprs_newcol, xprs_newrow, getsolution  Model a piecewise linear function using binary variables
createprob, chgbounds, xprs_newcol, xprs_addrow, getsolution  Optimize a composition of investment portfolios using semicontinuous variables
createprob, chgcoltype, chgglblimit, chgrhs, chgobjsense, xprs_newcol, xprs_newrow, getsolution  Find an optimal schedule of jobs on different machines and visualize the result in ggplot2
createprob, setprobname, xprs_newcol, xprs_newrow, xprs_addrow, setoutput, getdblattrib, getsolution  Solve two related problems assigning pilots to crews under different constraints
createprob, chgobjsense, chgobj, setprobname, xprs_newcol, xprs_addrow, setoutput, getsolution  Solve a timetabling problem for college courses under various constraints
createprob, chgbounds, chgobj, setprobname, xprs_newcol, xprs_newrow, setoutput, getsolution  Solve a small production problem with 2 products and 2 resource constraints
createprob, chgobjsense, setprobname, xprs_newcol, xprs_addrow, setoutput, getsolution  Solve a minimum cost flow problem in a bipartite graph
createprob, setprobname, xprs_newcol, xprs_addrow, setoutput, getsolution  Modeling a piecewise linear objective function using SOS2 constraints
createprob, setprobname, addsets, getdblattrib, xprs_newcol, xprs_addrow, setoutput, getsolution  Infeasibility and IIS Detection
createprob, getiisdata, getintattrib, iisall, iisstatus, iisisolations, xprs_newcol, xprs_newrow, xprs_optimize  Basis and Stability
bndsa, createprob, getbasis, getnamelist, loadbasis, objsa, rhssa, writebasis, writeslxsol, getsolution, xprs_newcol, xprs_newrow, xprs_optimize  Using the Tuner
createprob, setoutput, readprob, setintcontrol, tune, tunerreadmethod, tunerwritemethod, xprs_optimize  Goal programming
createprob, setoutput, xprs_newcol, xprs_addrow, chgobj, chgobjn, setobjintcontrol, setobjdblcontrol, xprs_optimize, getintattrib, getmipsol
 Xpress Kalis examples
 Xpress Kalis Mosel features
 Generic binary and nary constraints
Mosel subroutine implementing a constraint relation  Table constraint: solving a binpacking problem
Constraint definition via value tuples, optimization  Alldifferent constraint: solving an assignment problem
Constraint definition, check for feasible solution  'abs' and 'distance' constraints
Constraint definition  'distribute' and 'occurrence' constraints
Constraint definition, check for feasible solution, cardinality constraint  One and twodimensional 'element' constraints
Constraint definition  Implication and equivalence constraints
Constraint definition  Conjunctions and disjunctions (logical 'and' and 'or')
Constraint definition  'cycle' constraint: formulating a TSP problem
Constraint definition, solution callback, branching strategy  'cumulative' and 'disjunctive' constraints for scheduling and planning problems
Scheduling with resource constraints  'producer_consumer' constraints: solving a resourceconstrained project scheduling problem
Configuring resource and task objects, scheduling solver  Resource profiles
Alternative resources, nonconstant resource usage profiles  Minimum and maximum constraints
Constraint definition, constraint posting, cpvarlist  Defining, posting and propagating linear constraints
Automated propagation, automated post, explicit post, scalar product, dot product  Nonlinear constraints over realvalued decision variables
Branching strategy for cpfloatvar  Branching strategies
Branching schemes, enumeration for discrete or continuous variables, tasks, disjunctive constraints  Use of callbacks to output the search tree
Definition of branching callbacks  Working with 'reversible' objects
Setting and retrieving reversible values, behaviour on backtracking  Defining a linear relaxation
LP or MIP solving within a CP problem
 Xpress Kalis Mosel User Guide examples
 Introductory example: constraint handling
Automated and explicit constraint posting  Basic modeling tasks: data input, optimization, enumeration
Data input from file, solving, branching strategy  Production of cane sugar
Linear, 'ocurrence', and 'element' constraints  Sequencing jobs on a bottleneck machine
Linear, 'element', 'disjunctive' constraints  Planning of paint production
Linear, 'element', 'implies', and 'alldifferent', 'element' ,'cycle' constraints  Euler knight tour problem
'alldifferent', generic binary, 'cycle' constraints  Frequency assignment problem
'abs', 'distance', and 'alldifferent' constraints; branching strategy, solution callback  Choice of locations for income tax offices
Linear, 'element', 'occurrence', 'equiv' constraints; search strategy  Nonlinear constraints
Default bounds, cpfloatvar  Personnel planning problem
'all_different', 'implies', 'occurrence', and 'distribute' constraints  Sudoku puzzle: retrieving status information through parameters
'alldifferent' constraints, propagation algorithm, infeasibility conflict analysis  Assigning workers to machines: heuristics and userdefined search
Linear, 'alldifferent', and 'element' constraints, solution heuristic  Working with reversible numbers
Branching strategy, reversible numbers, branching callbacks  Scenes allocation problem: symmetry breaking
'implies', 'distribute', 'maximum' constraints, symmetry breaking  Construction of a stadium: project planning
Scheduling with precedence constraints, task objects  Backing up files: scheduling with cumulative resource constraints
Cumulative scheduling, task and resource objects  Jobshop scheduling
Task and resource objects, user search strategy  Renewable and nonrenewable resources
Provision/requirement of resource, production/consumption of resource  Resource usage profiles
Resource idle times, 'resusage', alternative resources  Linear relaxations
alldifferent' constraint reformulated by linear relaxations, userdefined linear relaxations
 Xpress Kalis Mosel application examples
 Project scheduling problem with disjunctive resource constraints
Scheduling objects, branching strategy  Solving the jobshop scheduling problem
Scheduling objects, solution callback  Frequency assignment with polarity
Submodel execution, solution heuristic  Resourceconstrained project scheduling problem
Scheduling objects, resource consumption, task modes, RCPSP, MRCPSP, renewable resource, element constraint
 Xpress MATLAB interface examples
 Mosel MATLAB interface examples
 Running Mosel models from MATLAB
Calling Mosel from MATLAB, data exchange in memory  Folio  example from 'Getting started' executed in MATLAB
Exchange model parameters and solution between MATLAB and Mosel  Evaluating MATLAB functions from Mosel
Using MATLAB functions in Mosel  MATLAB using the Mosel Java interface
Compile/load/run models from MATLAB
 Xpress Cloud examples
 S3
 Uploading a file to an S3 bucket
 Downloading a file from an S3 bucket
 List objects available in an S3 bucket
 Setting tags on an object in an S3 bucket
 Querying tags on an object in an S3 bucket
 Xpress Executor
 Solving a Mosel model using a REST webservice, from Mosel
 Solving a Mosel model using a REST webservice, from NodeJS
 Solving an MPS problem using a REST webservice, from NodeJS
 Solving a nonfixed Mosel model using a REST webservice, from Mosel
 Solving a Mosel model using the 'executor' package, from Mosel
 Making a request to a DMP component
 Making a request to DMP Manager
 Xpress Insight examples
 Mosel app examples
 Folio  Insight example from 'Getting started'
Mosel Insight app  Transport  Insight example from Mosel User Guide
 Lightweight execution modes
lightweight execution, partial entity population, custom execution modes, insightpopulate, insightcapture
 Python app examples
 Testing an Insight Python model
test mode, unit testing, pytest  Lightweight execution modes
lightweight execution, partial entity population, custom execution modes
