 Xpress BCL library examples
 Examples in C
 Chess  Composing constraints and solving
Simple LP problem, termwise constraint definition, LP solving  Workshop  Displaying solution information
Retrieving and displaying solution values and ranging information; real value printing format, number output format  Contract  Semicontinuous variables, predefined constraint functions, combine BCL with Xpress Optimizer
Defining semicontinuous variables, MIP solving  Chgprobs  Working with multiple problems
Handling multiple problems  Setops  Index sets
Using index sets, set operations  Burglar  Use of index sets, formulating logical constraints
Index an array of variables by an index set, defining indicator constraints  Coco  A full production planning example
Data input from text files  Delivery  Data input from file; infeasibility analysis
LP model, data input from file, retrieving IIS  Purchase  Definition of SOS2
Data input from file, using SOS2  Portfolio  Quadratic Programming with discrete variables
Quadratic objective function  Catenary  Solving a QCQP
Stating quadratic constraints  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  Fixbv  A binary fixing heuristic
Changing bounds, saving and loading bases, saving and loading start solutions  Recurse  A successive linear programming model
Iterative solving, modify constraint definitions  MT2  Solving two problems in parallel in a threadsafe environment
Parallel computing  GoalObj  Archimedian and preemptive goal programming using objective functions
Multicriteria optimization, multiobjective decision making  Wagon  MIP start solution heuristic
Loading MIP start solution, 'solnotify' callback  UG  Examples from 'BCL Reference Manual'
MIP modeling, error handling, using Xpress Optimizer with BCL  Folio  Examples from 'Getting Started'
MIP modeling, quadratic constraints, infeasibility handling, solution enumeration
 Examples in C++
 Chess  Composing constraints and solving
Simple LP problem, termwise constraint definition, LP solving  Workshop  Displaying solution information
Retrieving and displaying solution values and ranging information; real value printing format, number output format  Contract  Semicontinuous variables, predefined constraint functions, combine BCL with Xpress Optimizer
Defining semicontinuous variables, MIP solving  Chgprobs  Working with multiple problems
Handling multiple problems  Setops  Index sets
Using index sets, set operations  Burglar  Use of index sets, formulating logical constraints
Index an array of variables by an index set, defining indicator constraints  Coco  A full production planning example
Data input from text files  Delivery  Data input from file; infeasibility analysis
LP model, data input from file, retrieving IIS  Purchase  Definition of SOS2
Data input from file, using SOS2  Portfolio  Quadratic Programming with discrete variables
Quadratic objective function  Catenary  Solving a QCQP
Stating quadratic constraints  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  Fixbv  A binary fixing heuristic
Changing bounds, saving and loading bases, saving and loading start solutions  Recurse  A successive linear programming model
Iterative solving, modify constraint definitions  GoalObj  Archimedian and preemptive goal programming using objective functions
Multicriteria optimization, multiobjective decision making  Wagon  MIP start solution heuristic
Loading MIP start solution, 'solnotify' callback  UG  Examples from 'BCL Reference Manual'
MIP modeling, error handling, using Xpress Optimizer with BCL  Folio  Examples from 'Getting Started'
MIP modeling, quadratic constraints, infeasibility handling, solution enumeration  Folio  Examples from 'Getting started'
LP, MIP and QP models, explicit initialization, index sets, heuristic solution
 Examples in C#
 Chess  Composing constraints and solving
Simple LP problem, termwise constraint definition, LP solving  Workshop  Displaying solution information
Retrieving and displaying solution values and ranging information; real value printing format, number output format  Contract  Semicontinuous variables, predefined constraint functions, combine BCL with Xpress Optimizer
Defining semicontinuous variables, MIP solving  Chgprobs  Working with multiple problems
Handling multiple problems  Setops  Index sets
Using index sets, set operations  Burglar  Use of index sets, formulating logical constraints
Index an array of variables by an index set, defining indicator constraints  Coco  A full production planning example
Data input from text files  Delivery  Data input from file; infeasibility analysis
LP model, data input from file, retrieving IIS  Purchase  Definition of SOS2
Data input from file, using SOS2  Portfolio  Quadratic Programming with discrete variables
Quadratic objective function  Catenary  Solving a QCQP
Stating quadratic constraints  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  Fixbv  A binary fixing heuristic
Changing bounds, saving and loading bases, saving and loading start solutions  Recurse  A successive linear programming model
Iterative solving, modify constraint definitions  GoalObj  Archimedian and preemptive goal programming using objective functions
Multicriteria optimization, multiobjective decision making  Wagon  MIP start solution heuristic
Loading MIP start solution, 'solnotify' callback  UG  Examples from 'BCL Reference Manual'
MIP modeling, error handling, using Xpress Optimizer with BCL  Folio  Examples from 'Getting Started'
MIP modeling, quadratic constraints, infeasibility handling, solution enumeration
 Examples in Java
 Chess  Composing constraints and solving
Simple LP problem, termwise constraint definition, LP solving  Workshop  Displaying solution information
Retrieving and displaying solution values and ranging information; real value printing format, number output format  Contract  Semicontinuous variables, predefined constraint functions, combine BCL with Xpress Optimizer
Defining semicontinuous variables, MIP solving  Chgprobs  Working with multiple problems
Handling multiple problems  Setops  Index sets
Using index sets, set operations  Burglar  Use of index sets, formulating logical constraints
Index an array of variables by an index set, defining indicator constraints  Coco  A full production planning example
Data input from text files  Delivery  Data input from file; infeasibility analysis
LP model, data input from file, retrieving IIS  Purchase  Definition of SOS2
Data input from file, using SOS2  Portfolio  Quadratic Programming with discrete variables
Quadratic objective function  Catenary  Solving a QCQP
Stating quadratic constraints  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  Fixbv  A binary fixing heuristic
Changing bounds, saving and loading bases, saving and loading start solutions  Recurse  A successive linear programming model
Iterative solving, modify constraint definitions  GoalObj  Archimedian and preemptive goal programming using objective functions
Multicriteria optimization, multiobjective decision making  Wagon  MIP start solution heuristic
Loading MIP start solution, 'solnotify' callback  UG  Examples from 'BCL Reference Manual'
MIP modeling, error handling, using Xpress Optimizer with BCL  Folio  Examples from 'Getting Started'
MIP modeling, quadratic constraints, infeasibility handling, solution enumeration
 Xpress Mosel examples
 Models by problem type / modeling tasks
 Delivery: Infeasibility analysis with IIS
Retrieving and displaying IIS  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  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'  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  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  Conditional creation of decision variables
use of 'exists', finalization of index sets
 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
 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  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  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  Error handling
handling I/O errors during data input  Using counters
Using and combining 'count' and 'as counter'  Working with arrays
array initialization, indexation  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  Subroutines
Subroutine definition, overloading, recursive function calls, function return values  Output formatting
real number format, text formatting  Using the debugger and profiler
Debugging and profiling commands, parallel debugging  Checking memory usage
Using dynamic arrays  Writing packages: definition of constant symbols, subroutines, and types
Implementing subroutines, overloading, using packages  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
 Solving techniques
 Looping over optimization runs (within a model, batch executions, and multiple models/submodel)
Multiple problem runs, submodel  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  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 cut manager callback, addcuts, storecuts and loadcuts  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  Constructing and loading MIP start solutions for the traveling salesman problem (TSP)
CP target values, MIP start solution, MIP callbacks  Working with multiple models: submodels, coordination, communication, and parallelization
Parallel computing, distributed computing, distributed architecture, inmemory data exchange, shmem, job queue, events, detach submodel  DantzigWolfe decomposition: combining sequential and parallel solving
Concurrent subproblem solving, coordination via events, inmemory data exchange  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  Solving the TSP problem by a series of optimization subproblems
Solution heuristic, parallel submodel execution
 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  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 hand glider trajectory
Nonlinear constraints, trapezoidal discretization  Force required to lift an object
SOCP formulation
 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  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  Reading sparse data from text files, spreadsheets and databases, and from memory
Data input, initializations from, SQL, ODBC  Data output to text files, spreadsheets and databases, and to memory
Data output, initializations to, SQL, ODBC  Dense vs. sparse data format
array types  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 external types: dates and time
Types date, time, datetime; data input/output  Reading 3dimensional arrays
Multidimensional array input, option partndx
 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
 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
 Retrieving data from a Mosel model
Accessing sets and arrays; 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
 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
 Initialize Mosel sets from Python
 Invert a Mosel matrix with NumPy
 Python I/O driver example
 Puzzles and Recreational Mathematics
 Sudoku (CP model)
Using 'all_different', enumerating all feasible solutions  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  A DepthFirst Branching Algorithm
Using MIP node 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 global problem
Saving/loading bases, changing objective coefficients  Perform RHS parametrics on a global problem
Changing RHS coefficients, working with bases  Apply a primal heuristic to a knapsack problem
Using the global 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 global search information  Loading MIP solutions into 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
Preemptive and Archimedian Goal Programming with objective functions or constraints
 Calling the Optimizer library from Java
 Folio  Advanced modeling and solving tasks from 'Getting Started'
Using the solution enumerator and solution pool  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
 Calling the Optimizer library from C#.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 global 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 global search information
 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 global 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 global 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 the polygon examples as a black box function
Implementing user functions  Implementing user functions returning their own derivatives
Implementing complex user functions returning their own derivatives
 Calling the Nonlinear library from C#.NET
 Maximizing the area of a polygon using tokens based input
Using strings to express nonlinear formulas
 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  Numerical differentation and accuracy
Finite differences  Solution support sets
Support sets  Step bounding
Step bounding  Zero placeholders
Zero placeholders
 Xpress Python examples
 Python examples solving problems using the Xpress Optimizer
 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  Minimizing distance from constraints
 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  The travelling salesman problem
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
 Python examples solving problems using Xpress NonLinear
 Modeling with user functions
Modeling with user functions  Solving a quadratically constrained problem
Solve a nonlinear problem
 Xpress Kalis examples
 Xpress Kalis features
 Generic binary and nary constraints
Mosel subroutine implementing a constraint relation  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  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 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  Assigning workers to machines: heuristics and userdefined search
Linear, 'alldifferent', and 'element' constraints, solution heuristic  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 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
 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  Running Mosel models from MATLAB
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
