Xpress Optimizer Python interface

FICO



Xpress Optimization

User’s manual

Last update 3 June 2017

www.ﬁco.com Make every decision count

This material is the conﬁdential, proprietary, and unpublished property of Fair Isaac Corporation.

Receipt or possession of this material does not convey rights to divulge, reproduce, use, or allow

others to use it without the speciﬁc written authorization of Fair Isaac Corporation and use must

conform strictly to the license agreement.

The information in this document is subject to change without notice. If you ﬁnd any problems in

this documentation, please report them to us in writing. Neither Fair Isaac Corporation nor its

afﬁliates warrant that this documentation is error-free, nor are there any other warranties with

respect to the documentation except as may be provided in the license agreement.

documentation is governed by the software license agreement between the licensee and Fair Isaac

Corporation (or its afﬁliate). Portions of the program may contain copyright of various authors and

may be licensed under certain third-party licenses identiﬁed in the software, documentation, or

both.

In no event shall Fair Isaac Corporation or its afﬁliates be liable to any person for direct, indirect,

special, incidental, or consequential damages, including lost proﬁts, arising out of the use of this

software and its documentation, even if Fair Isaac Corporation or its afﬁliates have been advised of

the possibility of such damage. The rights and allocation of risk between the licensee and Fair Isaac

Corporation (or its afﬁliates) are governed by the respective identiﬁed licenses in the software,

documentation, or both.

Fair Isaac Corporation and its afﬁliates speciﬁcally disclaim any warranties, including, but not limited

to, the implied warranties of merchantability and ﬁtness for a particular purpose. The software and

accompanying documentation, if any, provided hereunder is provided solely to users licensed under

the Fair Isaac Software License Agreement. Fair Isaac Corporation and its afﬁliates have no

obligation to provide maintenance, support, updates, enhancements, or modiﬁcations except as

required to licensed users under the Fair Isaac Software License Agreement.

FICO and Fair Isaac are trademarks or registered trademarks of Fair Isaac Corporation in the United

States and may be trademarks or registered trademarks of Fair Isaac Corporation in other countries.

Other product and company names herein may be trademarks of their respective owners.

Xpress Optimizer

Deliverable Version: A

Last Revised: 3 June 2017

Contents

1 Introduction 1

1.1 Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Installing the Python Xpress module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2.1 Installation from the Xpress Optimizer distribution . . . . . . . . . . . . . . . . 1

1.2.2 Installation from Conda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Modeling an optimization problem 3

2.1 Getting started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2 Creating a problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.3 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.4 Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.5 Objective function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.6 Special Ordered Sets (SOSs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.7 Indicator constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.8 Modeling and solving nonlinear problems . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.9 Solving a problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.10 Querying a problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.11 Reading and writing a problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.12 Hints for building models efﬁciently . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Using Python numerical libraries 12

3.1 Using NumPy in the Xpress Python interface . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.2 Products of NumPy arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4 Controls and Attributes 14

4.1 Controls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.2 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.3 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.4 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4.5 Accessing controls and attributes as object members . . . . . . . . . . . . . . . . . . . 16

5 Using Callbacks 19

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6 Examples of use 21

6.1 Creating simple problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.1.1 Generating a small Linear Programming problem . . . . . . . . . . . . . . . . . 21

6.1.2 A Mixed Integer Linear Programming problem . . . . . . . . . . . . . . . . . . . 22

6.2 Modeling examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.2.1 A simple model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.2.2 Using IIS to investigate an infeasible problem . . . . . . . . . . . . . . . . . . . 23

6.2.3 Modeling a problem using Python lists and vectors . . . . . . . . . . . . . . . . 24

6.2.4 A knapsack problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

6.2.5 A Min-cost-ﬂow problem using NumPy . . . . . . . . . . . . . . . . . . . . . . . 25

6.2.6 A nonlinear model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.2.7 Finding the maximum-area n-gon . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Fair Isaac Corporation Conﬁdential and Proprietary Information i

Contents

6.2.8 Solving the n-queens problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.2.9 Solving Sudoku problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.3 Examples using NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

6.3.1 Using NumPy multidimensional arrays to create variables . . . . . . . . . . . . . 28

6.3.2 Using the dot product to create arrays of expressions . . . . . . . . . . . . . . . 29

6.3.3 Using the Dot product to create constraints and quadratic functions . . . . . . 29

6.3.4 Using NumPy to create quadratic optimization problems . . . . . . . . . . . . . 30

6.4 Advanced examples: callbacks and problem querying/modifying . . . . . . . . . . . . 30

6.4.1 Visualize the branch-and-bound tree of a problem . . . . . . . . . . . . . . . . 30

6.4.2 Query and modify a simple problem . . . . . . . . . . . . . . . . . . . . . . . . . 32

6.4.3 Change a problem after solution . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6.4.4 Combining modeling and API functions . . . . . . . . . . . . . . . . . . . . . . . 34

6.4.5 A simple Traveling Salesman Problem (TSP) solver . . . . . . . . . . . . . . . . . 34

7 Reference Manual 38

7.1 Using this chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Format of the reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

7.2 Global methods of the Xpress module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

7.3 Methods of the problem class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

7.4 Methods for branching objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

7.5 Methods for adding/removing callbacks of a problem object . . . . . . . . . . . . . . . 42

7.6 Methods to be used within a callback of a problem object . . . . . . . . . . . . . . . . 42

xpress.free . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

xpress.getbanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

xpress.getcheckedmode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

xpress.getdaysleft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

xpress.getlasterror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

xpress.getlicerrmsg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

xpress.getversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

xpress.init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

xpress.setcheckedmode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

xpress.setdefaults . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

xpress.setdefaultcontrol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

xpress.Sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

xpress.Dot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

xpress.Prod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

xpress.exp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

xpress.log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

xpress.log10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

xpress.sin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

xpress.cos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

xpress.tan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

xpress.asin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

xpress.acos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

xpress.atan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

xpress.max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

xpress.min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

xpress.abs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

xpress.sign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

xpress.erf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

xpress.erfc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

xpress.sqrt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

xpress.user . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

xpress.addcbmsghandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

xpress.removecbmsghandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Fair Isaac Corporation Conﬁdential and Proprietary Information ii

Contents

problem.addcbbariteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

problem.addcbbarlog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

problem.addcbchgbranchobject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

problem.addcbcutlog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

problem.addcbdestroymt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

problem.addcbgapnotify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

problem.addcbgloballog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

problem.addcbinfnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

problem.addcbintsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

problem.addcblplog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

problem.addcbmessage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

problem.addcbmipthread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

problem.addcbnewnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

problem.addcbnodecutoff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

problem.addcboptnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

problem.addcbpreintsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

problem.addcbprenode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

problem.addcbusersolnotify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

problem.addcoefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

problem.addcols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

problem.addConstraint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

problem.addcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

problem.adddfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

problem.addIndicator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

problem.addmipsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

problem.addqmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

problem.addrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

problem.addSOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

problem.addtolsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

problem.addVariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

problem.addvars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

problem.basisstability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

problem.btran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

problem.calcobjective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

problem.calcreducedcosts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

problem.calcslacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

problem.calcsolinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

problem.cascade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

problem.cascadeorder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

problem.chgbounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

problem.chgcoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

problem.chgcoltype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

problem.chgcascadenlimit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

problem.chgccoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

problem.chgdeltatype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

problem.chgdf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

problem.chgglblimit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

problem.chgmcoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

problem.chgmqobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

problem.chgnlcoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

problem.chgobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

problem.chgobjsense . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

problem.chgqobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

problem.chgqrowcoeff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

problem.chgrhs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

Fair Isaac Corporation Conﬁdential and Proprietary Information iii

Contents

problem.chgrhsrange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

problem.chgrowstatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

problem.chgrowtype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

problem.chgrowwt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

problem.chgtolset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

problem.chgvar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

problem.construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

problem.copy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

problem.copycallbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

problem.copycontrols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

problem.delcoefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

problem.delConstraint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

problem.delcpcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

problem.delcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

problem.delqmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

problem.delSOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

problem.deltolsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

problem.delVariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

problem.delvars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

problem.dumpcontrols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

problem.estimaterowdualranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

problem.evaluatecoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

problem.evaluateformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

problem.ﬁlesol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

problem.ﬁxglobals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

problem.ﬁxpenalties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

problem.ftran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

problem.getAttrib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

problem.getattribinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

problem.getbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

problem.getccoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

problem.getcoef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

problem.getcoefformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

problem.getcoefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

problem.getcolinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

problem.getcols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

problem.getcoltype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

problem.getConstraint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

problem.getControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

problem.getcontrolinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

problem.getcpcutlist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

problem.getcpcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

problem.getcutlist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

problem.getcutmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

problem.getcutslack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

problem.getdirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

problem.getdf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

problem.getdtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

problem.getDual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

problem.getdualray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

problem.getglobal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

problem.getiisdata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

problem.getIndex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

problem.getIndexFromName . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

problem.getindicators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

Fair Isaac Corporation Conﬁdential and Proprietary Information iv

Contents

problem.getinfeas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

problem.getlasterror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

problem.getlb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

problem.getlpsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

problem.getmessagestatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

problem.getmessagetype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

problem.getmipsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

problem.getmqobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

problem.getobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

problem.getObjVal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

problem.getpivotorder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

problem.getpivots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

problem.getpresolvebasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

problem.getpresolvemap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

problem.getpresolvesol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

problem.getprimalray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

problem.getProbStatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

problem.getProbStatusString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

problem.getqobj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

problem.getqrowcoeff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

problem.getqrowqmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

problem.getqrowqmatrixtriplets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

problem.getqrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

problem.getRCost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

problem.getrhs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

problem.getrhsrange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

problem.getrowinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

problem.getrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

problem.getrowstatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

problem.getrowtype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

problem.getrowwt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

problem.getscaledinfeas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

problem.getSlack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

problem.getslpsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

problem.getSolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

problem.getSOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

problem.gettolset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

problem.getub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

problem.getunbvec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

problem.getvar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

problem.getVariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

problem.globalsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

problem.hasdualray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

problem.hasprimalray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238

problem.iisall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

problem.iisclear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

problem.iisﬁrst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

problem.iisisolations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

problem.iisnext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

problem.iisstatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

problem.iiswrite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

problem.interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

problem.loadbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

problem.loadbranchdirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

problem.loadcoefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

Fair Isaac Corporation Conﬁdential and Proprietary Information v

Contents

problem.loadcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

problem.loaddelayedrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

problem.loaddfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

problem.loaddirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

problem.loadlpsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

problem.loadmipsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

problem.loadmodelcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

problem.loadpresolvebasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

problem.loadpresolvedirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

problem.loadproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

problem.loadsecurevecs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

problem.loadtolsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

problem.loadvars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

problem.lpoptimize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

problem.mipoptimize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

problem.msaddcustompreset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

problem.msaddjob . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

problem.msaddpreset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

problem.msclear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

problem.name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

problem.objsa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

problem.parsecformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

problem.parseformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

problem.postsolve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

problem.preparseformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

problem.presolve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

problem.presolverow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

problem.printmemory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

problem.printevalinfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

problem.printmsg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

problem.read . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

problem.readbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

problem.readbinsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

problem.readdirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

problem.readslxsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

problem.reﬁnemipsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288

problem.reinitialize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

problem.removecbbariteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

problem.removecbbarlog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

problem.removecbchgbranchobject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

problem.removecbcutlog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

problem.removecbdestroymt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

problem.removecbgapnotify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

problem.removecbgloballog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

problem.removecbinfnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

problem.removecbintsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298

problem.removecblplog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

problem.removecbmessage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

problem.removecbmipthread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

problem.removecbnewnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

problem.removecbnodecutoff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

problem.removecboptnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

problem.removecbpreintsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305

problem.removecbprenode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

problem.removecbusersolnotify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

Fair Isaac Corporation Conﬁdential and Proprietary Information vi

Contents

problem.repairinfeas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

problem.repairweightedinfeas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

problem.repairweightedinfeasbounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

problem.reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

problem.restore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

problem.rhssa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

problem.save . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

problem.scale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

problem.scaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

problem.setbranchbounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

problem.setbranchcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

problem.setcbcascadeend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

problem.setcbcascadestart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

problem.setcbcascadevar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

problem.setcbcascadevarfail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

problem.setcbcoefevalerror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326

problem.setcbconstruct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

problem.setcbdestroy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

problem.setcbdrcol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

problem.setcbformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

problem.setcbiterend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332

problem.setcbiterstart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

problem.setcbitervar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

problem.setcbmessage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335

problem.setcbmsjobend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336

problem.setcbmsjobstart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

problem.setcbmswinner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

problem.setcbslpend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

problem.setcbslpnode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340

problem.setcbslpstart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

problem.setControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

problem.setcurrentiv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

problem.setdefaultcontrol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

problem.setdefaults . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

problem.setindicators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

problem.setlogﬁle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347

problem.setmessagestatus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

problem.setObjective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

problem.setprobname . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

problem.setuniquepreﬁx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

problem.solve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352

problem.storebounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

problem.storecuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354

problem.strongbranch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

problem.strongbranchcb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

problem.tokencount . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

problem.tune . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358

problem.tunerreadmethod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

problem.tunerwritemethod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

problem.unconstruct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361

problem.updatelinearization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

problem.validate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363

problem.validatekkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364

problem.validaterow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365

problem.validatevector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366

Fair Isaac Corporation Conﬁdential and Proprietary Information vii

Contents

problem.validformula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

problem.write . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368

problem.writebasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369

problem.writebinsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370

problem.writedirs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

problem.writeprtsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

problem.writeslxsol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373

problem.writesol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

branchobj.addbounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

branchobj.addbranches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

branchobj.addcuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

branchobj.addrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

branchobj.getbounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

branchobj.getbranches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

branchobj.getid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

branchobj.getlasterror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

branchobj.getrows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

branchobj.setpreferredbranch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384

branchobj.setpriority . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

branchobj.store . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

branchobj.validate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387

Appendix 388

A Contacting FICO 388

Product support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

Product education . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

Product documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

Sales and maintenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

Related services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

About FICO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

Index 390

Fair Isaac Corporation Conﬁdential and Proprietary Information viii

CHAPTER 1

Introduction

The Xpress Python interface allows for creating and solving optimization problems using the

Python programming language and the FICO Xpress Optimizer library. This manual describes how

to use the Xpress Python interface.

1.1 Outline

The following chapters cover:

 Creating, handling, solving, and querying optimization problems (Chapter 2);

 Using Python numerical libraries such as NumPy when creating optimization problems

(Chapter 3);

 Setting and getting the value of controls, and getting the value of attributes of a problem

(Chapter 4).

 Using Python functions as callbacks for the Xpress Optimizer and the Xpress Nonlinear

solver (Chapter 5);

 Several examples of usage of the Xpress Python interface (Chapter 6).

 A reference with all functions and parameters in the Python interface (Chapter 7).

It is assumed here that the reader has basic understanding of the Python programming language.

Ample documentation on Python is available at http://docs.python.org, including a tutorial and a

reference manual. Unless speciﬁed otherwise, Python 3 is used in all of the examples and code

samples throughout this manual. The current version of the Xpress Python interface works on

Python 2.7, Python 3.4, and subsequent versions.

1.2 Installing the Python Xpress module

1.2.1 Installation from the Xpress Optimizer distribution

Using the Xpress Optimizer suite, the module is automatically installed by the installation script.

If xpress_dir is the directory where the Xpress Optimizer suite was installed (for example

c:\xpressmp for Windows users or /opt/xpressmp for *nix users), then the Python module is at

xpress_dir/lib for *nix users and xpress_dir\bin for Windows users.

Documentation is available under xpress_dir/docs/python, both in PDF form (see

xpress_dir/docs/python/xpress_python_interface.pdf) and as a set of HTML pages (see

xpress_dir/docs/python/dhtml/index.html).

Fair Isaac Corporation Conﬁdential and Proprietary Information 1

Introduction

1.2.2 Installation from Conda

A Conda package is available for download with the following command:

conda install -c fico-xpress xpress

Conda packages for Python 2.7, 3.4, 3.5, and 3.6 are available, for Windows, Linux, and MacOS.

The Conda package contains the Python interface module and its documentation, but not the

Xpress Optimizer’s libraries, its documentation, or a license. Please refer to the FICO Xpress

Optimizer web pages for instructions on how to obtain a full installation of the Xpress

optimization suite, which also contains an installation package that is compatible with Conda.

Fair Isaac Corporation Conﬁdential and Proprietary Information 2

CHAPTER 2

Modeling an optimization problem

This chapter illustrates the modeling capabilities of the Xpress Python interface. It shows how to

create variables, constraints of different types, add an objective function, and solving and

retrieving a problem’s solution. It also shows how to read or write a problem from/to a ﬁle.

2.1 Getting started

The Xpress Python module is imported as follows:

import xpress

A complete list of methods and constants available in the module is obtained by running the

Python command dir (xpress). Because all types and methods must be called by prepending

"xpress.", it is advisable to alias the module name upon import:

import xpress as xp

We assume that this is the way the module is imported from now on. It is also possible to import

all methods and types to avoid prepending the module name or its alias, but this practice is

usually advised against:

from xpress import *

2.2 Creating a problem

Create an empty optimization problem myproblem as follows:

myproblem = xp.problem ()

A name can be assigned to a problem upon creation:

myproblem = xp.problem (name = "My first problem")

The problem has no variables or constraint at this point.

2.3 Variables

The Xpress type var allows for creating optimization variables. Note that variables are not tied to

a problem but may exist globally in a Python program. In order for them to be included into a

Fair Isaac Corporation Conﬁdential and Proprietary Information 3

Modeling an optimization problem

problem, they have to be explicitly added to that problem. Below is the complete declaration

with the list of all parameters (all of them are optional):

var (name, lb, ub, threshold, vartype)

The parameters are:

1. name is a Python UTF-8 string containing the name of the variable (its ASCII version will be

saved if written onto a ﬁle); a default name is assigned if the user does not specify it;

2. lb is the lower bound (0 by default);

3. ub is the upper bound (+inf is the default);

4. threshold is the threshold for semi-continuous, semi-integer, and partially integer variables;

it must be between its lower and its upper bound; it has no default, so if a variable is

deﬁned as partially integer the threshold must be speciﬁed;

5. vartype is the variable type, one of the six following types:

 xpress.continuous for continuous variables;

 xpress.binary for binary variables (lower and upper bound are further restricted to 0

and 1);

 xpress.integer for integer variables;

 xpress.semicontinuous for semi-continuous variables;

 xpress.semiinteger for semi-integer variables;

 xpress.partiallyinteger for partially integer variables.

The features of each variable are accessible as members of the associated object: after declaring a

variable with x = xpress.var(), its name, lower and upper bound can be accessed via x.name,

x.lb, and x.ub. Note that, after a variable x has been added to one or more problems, a change

in its feature will not be reﬂected in these problems, but only in the problems to which this

variable is added subsequently.

One or more variables (or vectors of variables) can be added to a problem with the addVariable

method:

v = xp.var (lb = -1, ub = 2)

m.addVariable (v)

x = [xp.var (ub = 10) for i in range (10)]

y = [xp.var (ub = 10, vartype = xp.integer) for i in range (10)]

m.addVariable (x,y)

2.4 Constraints

Linear, quadratic, and nonlinear constraints can be speciﬁed as follows:

constraint (constraint, body, lb, ub, sense, rhs, name)

The parameters are:

1. constraint is the full-form constraint, such as x1 + 2 * x2 <= 4;

Fair Isaac Corporation Conﬁdential and Proprietary Information 4

Modeling an optimization problem

2. body is the body of the constraint, such as 3 * x1 + x2 (it may contain constants);

3. lb is the lower bound on the body of the constraint;

4. ub is the upper bound on the body of the constraint;

5. sense is the sense of the constraint, one among xpress.leq, xpress.geq, xpress.eq, and

xpress.range; in the ﬁrst three cases, the parameter rhs must be speciﬁed; only in the

fourth case must lb and ub be speciﬁed;

6. rhs is the right-hand side of the constraint;

7. name is the name of the constraint. Parameters lb, ub, and rhs must be constant.

A constraint can be speciﬁed more naturally as a condition on an expression:

myconstr = x1 + x2 * (x2 + 1) <= 4

myconstr2 = xp.exp (xp.sin (x1)) + x2 * (x2**5 + 1) <= 4

One or more constraints (or vectors of constraints) can be added to a problem via the

addConstraint method:

m.addConstraint (myconstr)

m.addConstraint (v1 + xp.tan (v2) <= 3)

m.addConstraint (x[i] + y[i] <= 2 for i in range (10))

In order to help formulate compact problems, the Sum operator of the xpress module can be used

to express sums of expressions. Its argument is a list of expressions:

m.addConstraint (xp.Sum ([y[i] for i in range (10)]) <= 1)

m.addConstraint (xp.Sum ([x[i]**5 for i in range (9)]) <= x[9])

When handling variables or expressions, it is advised to use the Sum operator in the Xpress module

rather than the native Python operator, for reasons of efﬁciency.

As for variables, an object of type constraint allows for read/write access of its features via its

members name, body, lb, and ub. The same caveat for variables holds here: any change to an

object’s members will only have an effect in the problems to which a constraint is added after the

change.

2.5 Objective function

The objective function is any expression, so it can be constructed as for constraints. The method

setObjective can be used to set (or replace if one has been speciﬁed before) the objective

function of a problem. The deﬁnition of setObjective is as follows:

setObjective (objective, sense)

where objective is the expression deﬁning the new objective and sense is either

xpress.minimize or xpress.maximize. Examples follows (in the ﬁrst, the objective function is to

be minimized as per default, while the second example speciﬁes the optimization sense as

maximization).

m.setObjective (xp.Sum ([y[i]**2 for i in range (10)]))

m.setObjective (v1 + 3 * v2, sense = xp.maximize)

Fair Isaac Corporation Conﬁdential and Proprietary Information 5

Modeling an optimization problem

2.6 Special Ordered Sets (SOSs)

A Special Order Set (SOS) is a modeling tool for constraining a small number of consecutive

variables in a vector to be nonzero. The Xpress Python interface allows for deﬁning a SOS as

follows:

sos (indices, weights, type, name)

The ﬁrst argument, indices, is a list of variables, while weights is a list of ﬂoating point numbers.

The type of SOS (either 1 or 2) is speciﬁed by type. While indices and weights are mandatory

parameters, type and name are not; type is set to a default of 1 when not speciﬁed. Examples

follow:

set1 = xp.sos (x, [0.5 + i*0.1 for i in range(10)], type = 2)

set2 = xp.sos ([y[i] for i in range(5)], [i+1 for i in range(5)])

set3 = xp.sos ([v1, v2], [2, 5], 2)

One or more SOS can be added to a problem via the addSOS method:

set1 = xp.sos (x, [0.5 + i*0.1 for i in range(10)], type = 2)

m.addSOS (set1)

n = 10

w = [xp.var () for i in range (n)]

m.addSOS ([xpr.sos ([w[i],w[i+1]], [2,3], type = 2) for i in range (n-1)])

The name member of a SOS object can be read and written by the user.

2.7 Indicator constraints

Indicator constraints are deﬁned by a binary variable, called the indicator, and a constraint.

Depending on the value of the indicator, the constraint is enforced or relaxed.

For instance, if the constraint x + y ≥ 3 should only be enforced if the binary variable u is equal to

1, then (u = 1 → x + y ≥ 3) is an indicator constraint.

An indicator constraint in Python can be added to a problem with the addIndicator as follows

(note the "==" as the symbol for equality):

m.addIndicator (vb == 1, v1 + v2 >= 4)

2.8 Modeling and solving nonlinear problems

Version 8.3 of the Xpress Optimizer suite introduces nonlinear modeling in the Python interface.

It allows for creating and solving nonlinear, possibly nonconvex problems with similar functions

as for linear, quadratic, and conic problems and their mixed integer counterpart.

A nonlinear problem can be deﬁned by creating one or more variables and then adding

constraints and an objective function. This can be done using the same Python calls as one would

do for other problems. The available operators are +, -, *, /, ** (which is the Python equivalent

for the power operator ). Univariate functions can also be used from the following list: sin, cos,

tan, asin, acos, atan, exp, log, log10, abs, sign, and sqrt. Multivariate functions are min and max,

which can receive an arbitrary number of arguments.

Examples of nonlinear constraints are as follows:

Fair Isaac Corporation Conﬁdential and Proprietary Information 6

Modeling an optimization problem

import xpress as xp

import math

x = xp.var ()

p = xp.problem ()

p.addVariable (x)

# polynomial constraint

p.addConstraint (x**4 + 2 * x**2 - 5 >= 0)

# A terrible way to constrain x to be integer

p.addConstraint (xp.sin (math.pi * x) == 0)

p.addConstraint (x**2 * xp.sign (x) <= 4)

Note that non-native mathematical functions such as log and sin must be preﬁxed with xpress

or its alias, xp in this case. This can be avoided by importing all symbols from xpress using the

import * command as follows

from xpress import *

x = var()

a = sin(x)

but this hides namespaces and is usually frowned upon.

User functions are also accepted in the Python interface, and must be speciﬁed with the keyword

user and the function as the ﬁrst argument. They are handled in the Nonlinear solver in a

transparent way, so all is needed is to deﬁne a Python function to be run as the user function and

specify it in the problem with user, as in the following example:

import xpress as xp

import math

def mynorm (x1, x2):

return math.sqrt (x1**2 + x2**2)

def myfun (v1, v2, v3):

return v1 / v2 + math.cos (v3)

x,y = xp.var (), xp.var ()

p = xp.problem ()

p.addVariables (x,y)

p.setObjective (user (mynorm, x, y))

p.addConstraint (x+y >= 2)

p.addConstraint (user (myfun, x**2, x**3, 1/y) <= 3)

As a ﬁnal word of caution, solving nonlinear problem requires a preprocessing step that is

transparent to the user except for two steps: ﬁrst, if the objective function has a nonlinear

component f(x) then a new constraint (called objective transfer row or objtransrow) and a new

variable, the objective transfer column or objtranscol) are called that are deﬁned as follows:

objtransrow : −objtranscol + f(x) = 0

The resulting problem is equivalent in that the set of optimal (resp. feasible) solutions of this

problem will be the same as those of the original problem. The user, however, will notice an

increase by one of both the number of rows and of columns when a nonlinear objective function

is set.

The second caveat is about yet another variable that may be added to the problem for reasons

Fair Isaac Corporation Conﬁdential and Proprietary Information 7

Modeling an optimization problem

having to do with one of the Xpress Nonlinear solvers. This variable is called equalscol and it is

ﬁxed to 1. Its existence and value are therefore of no interest to the user.

The reader can ﬁnd more information on this in the Xpress Nonlinear reference manual.

2.9 Solving a problem

Simply call solve() to solve an optimization problem that was either built or read from a ﬁle. The

type of solver is determined based on the type of problem: if at least one integer variable was

declared, then the problem will be solved as a mixed integer (linear, quadratically constrained, or

nonlinear) problem, while if all variables are continuous the problem is solved as a continuous

optimization problem. If the problem is nonlinear in that it contains non-quadratic, non-conic

nonlinear constraints, then the appropriate nonlinear solver of the Xpress Optimization suite will

be called. Note that in case of a nonconvex quadratic problem, the Xpress Nonlinear solver will

be applied as the Xpress Optimizer solver cannot handle such problems.

m.solve ()

The status of a problem after solution can be inquired via the functions getProbStatus() and

getProbStatusString() as follows:

import xpress as xp

m = xp.problem ()

m.read ("example3.lp")

m.solve ()

print ("problem status: ", m.getProbStatus ())

print ("problem status, explained: ", m.getProbStatusString ())

The meaning of the returned value is explained in the Optimizer’s reference manual. Note that

the value and string returned by the above functions reﬂect the type of problem as input by the

user, not the way the problem was last solved. If the user creates a MILP and then solves it as an

LP with the ﬂag "l", then both getProbStatus() and getProbStatusString() yield the status of

the MILP rather than the LP relaxation. At all effects, the call p.getProbStatus() returns

p.attributes.lpstatus if p has continuous variables and p.attributes.mipstatus if p has integer

variables.

2.10 Querying a problem

It is useful, after solving a problem, to obtain the value of an optimal solution. After solving a

continuous or mixed integer problem, the two methods getSolution and getSlack return the

vector (of portions thereof) of an optimal solution or the slack of the constraints. If an optimal

solution was not found but a feasible solution is available, these methods will return data based

on this solution. They can be used in multiple ways as shown in the following examples:

import xpress as xp

v1 = xp.var ()

x = [xp.var (lb = -1, ub = 1, vartype = xp.integer) for i in range(10)]

m = xp.problem ()

m.addVariable (v1, x)

[...] # add constraints and objective

Fair Isaac Corporation Conﬁdential and Proprietary Information 8

Modeling an optimization problem

m.solve()

print (m.getSolution ()) # prints a list with an optimal solution

print ("v1 is", m.getSolution (v1)) # only prints the value of v1

a = m.getSolution (x) # gets the values of all variables in the vector x

b = m.getSolution (0:4) # gets the value of v1 and x[0], x[1], x[2]

Consider the last four commands. The ﬁrst of them returns a list of ncol ﬂoating point scalars,

where ncol is the number of variables of the problem (nrow is the number of constraints, the size

of the vector returned by getSlack) containing the full solution. The second example retrieves

the value of the single variable v1. The third example returns an array of the same size as x with

the value of all variables of the list x. Finally, the fourth example shows that a range of indices

can be speciﬁed in order to obtain a vector of values without specifying the corresponding

variables. Recall that the column and row indices begin at 0.

The method getSlack works similarly, except constraints or integer indices must be passed. The

following examples illustrate a few possible uses.

import xpress as xp

N = 10

x = [xp.var (vartype = xp.binary) for i in range(N)]

m = xp.problem ()

m.addVariable (x)

con1 = xp.Sum (x[i] * i for i in range (N)) <= N)

con2 = (x[i] >= x[i+1] for i in range (N-1))

m.addConstraints (con1, con2)

m.setObjective (xp.Sum (x[i] for i in range (N))

m.solve ()

print (m.getSlack ()) # prints a list of slacks for all N constraints

print ("slack_1 is", m.getSlack (con1)) # only prints the slack of con1

a = m.getSlack (con2) # gets the slack of N-1 constraints con2

b = m.getSlack (0:2) # gets the slack of con1 and con2[0]

In addition, for problems with only continuous variables, the two methods getDual and getRCost

return the the vector (or a portion thereof) of dual variables and reduced costs, respectively. Their

usage is similar to that for getSolution and getSlack.

Note that the inner workings of the Python interface obtain a copy of the whole solution, slack,

dual, or reduced cost vectors, even if only one element is requested. It is therefore advisable that

instead of repeated calls (for instance, in a loop) to getSolution, getSlack, etc. only one call is

made and the result is stored in a list to be consulted in the loop. Hence, in the following

example:

import xpress as xp

n = 10000

N = range (n)

x = [xp.var () for i in N]

p = xp.problem ()

p.addVariable (x)

m.addConstraints (xp.Sum (x[i] * i for i in N) <= n))

m.setObjective (xp.Sum (x[i] for i in N)

m.solve ()

Fair Isaac Corporation Conﬁdential and Proprietary Information 9

Modeling an optimization problem

for i in N:

if m.getSolution (x[i]) > 1e-3:

print (i)

the last three lines should be substituted as follows, as this will prevent repeatedly copying a

large (10,000) vector:

sol = m.getSolution ()

for i in N:

if sol[i] > 1e-3:

print (i)

2.11 Reading and writing a problem

After creating an empty problem, method, one can read a problem from a ﬁle via the read

method, which only takes the ﬁle name as its argument. An already-built problem can be written

to a ﬁle with the write method. Its arguments are similar to those in the Xpress Optimizer API

function XPRSwriteprob, to which we refer.

import xpress as xp

m = xp.problem ()

m.read ("example2.lp")

m.solve ()

print (m.getSolution ())

m2 = xp.problem ()

v1 = xp.var ()

v2 = xp.var (vartype = xp.integer)

m2.addVariable (v1, v2)

m2.addConstraint (v1 + v2 <= 4)

m2.setObjective (v1**2 + v2)

m2.write ("twovarsproblem", "lp")

2.12 Hints for building models efﬁciently

The Xpress Python interface allows for creating optimization models using methods described in

this and other sections. As happens with other interpreted languages, using explicit loops may

result in a slow Python script. When using the Xpress Python interface, this can be noticeable in

large optimization models if multiple calls to addVariable, addConstraint, or addSOS are made.

For this reason, the Xpress module allows for generators and list, dictionaries, and sequences as

arguments to these methods, to ensure faster execution.

Let us consider an example:

import xpress as xp

N = 100000

S = range(N)

x = [xp.var() for i in S]

y = [xp.var(vartype = xp.binary) for i in S]

for i in S:

m.addVariable (x[i])

Fair Isaac Corporation Conﬁdential and Proprietary Information 10

Modeling an optimization problem

m.addVariable (y[i])

for i in S:

m.addConstraint (x[i] <= y[i])

m.solve()

While the declaration of x and y is correct and efﬁcient, the two subsequent loops are very

inefﬁcient: they imply 2N calls to addVariable and N calls to addConstraint. Both methods add

some overhead due to the conversion of Python object into data that can be read by the

Optimizer, and the total overhead can be large.

Most methods of the Xpress Python interface allow for passing sequences (lists, dictionaries,

NumPy arrays, etc.) as parameters, and are automatically recognized as such. Hence the ﬁrst loop

can be replaced by two calls to addVariable:

m.addVariable (x)

m.addVariable (y)

or, more compact and slightly more efﬁcient:

m.addVariable (x,y)

The largest gain in performance, though, comes from replacing the second loop with a single call

to addConstraint:

m.addConstraint (x[i] <= y[i] for i in S)

This line is equivalent to the second loop above, and it is much faster and more elegant.

When declaring x and y as NumPy vectors, an equally efﬁcient and even more compact model can

be written:

import xpress as xp

import numpy as np

N = 100000

S = range(N)

x = np.array ([xp.var () for i in S])

y = np.array ([xp.var (vartype = xp.binary) for i in S])

m.addVariable (x,y)

m.addConstraint (x <= y)

m.solve()

See Chapter 3 for more information on how to use NumPy arrays in the Xpress Python interface.

Fair Isaac Corporation Conﬁdential and Proprietary Information 11

CHAPTER 3

Using Python numerical libraries

The NumPy library allows for creating and using arrays of any order and size for efﬁciency and

compactness purposes. This chapter shows how to take advantage of the features of NumPy in

the creation of optimization problems. The Xpress Python interface works with NumPy versions

1.10 and above.

3.1 Using NumPy in the Xpress Python interface

NumPy arrays can be used as usual when creating variables, functions (linear and quadratic) of

variables, and constraints. All functions described in this manual that take lists or tuples as

arguments can take array’s, i.e., NumPy array objects, as well, as in the following example:

import numpy as np

import xpress as xp

N = 20

S = range (N)

x = np.array ([xp.var () for i in S])

y = np.array ([xp.var (vartype = xp.binary) for i in S])

constr1 = x <= y

p = xp.problem ()

p.addVariable (x, y)

p.addConstraint (constr1)

The above script imports both NumPy and the Xpress Python interface, then declares two arrays of

variables and creates the set of constraints x

≤ y

for all i in the set S.

As happens for all NumPy operations, all operations are replicated on each element of an array,

taking into account all broadcasting features. For example, the following script “broadcasts” the

right-hand side 1 to all elements of the array, thus creating the set of constraints x

+ y

≤ 1 for all

i in the set S.

constr2 = x + y <= 1

All these operations can be carried out on arrays of any number of dimensions, and can be

aggregated at any level. The following example shows two three-dimensional array of variables

involved in two systems of constraints: the ﬁrst has two variables per each of the 200 constraints,

while the second has 10 constraints and 20 variables in each constraint.

z = np.array ([xp.var () for i in range (200)]).reshape (4,5,10)

t = np.array ([xp.var (vartype = xp.binary) for i in range (200)]).reshape (4,5,10)

p.addVariable (z,t)

p.addConstraint (z**2 <= 1 + t)

p.addConstraint (xp.Sum (z[i][j][k] for i in range (4) for j in range (5)) <= 4

for k in range (10))

Fair Isaac Corporation Conﬁdential and Proprietary Information 12

Using Python numerical libraries

3.2 Products of NumPy arrays

The dot product is a useful operator for carrying out aggregate operations on vectors, matrices,

and tensors. The dot operator in NumPy allows for reducing, along one axis of a multi-dimensional

arrays, data such as ﬂoating points or integer values.

The application of the dot product of NumPy of two multi-dimensional arrays of dimensions

, i

, . . . , i

) and (j

, j

, . . . , j

), respectively, requires that i

= j

−1

, i.e., the size of the last

dimension of the ﬁrst array must match the size of the penultimate dimension of the second

vector. For instance, the following dot product is valid:

import numpy as np

a = np.random.random (4,6)

b = np.random.random (6,2)

c = np.dot (a,b)

and the result is a 4x2 matrix. The Xpress Python interface has its own dot product operator,

which can be used for all similar operations on variables and expression. The rules for applying

the Xpress dot operator are the same as for the native Python dot product, with one extra

feature: there is no limit on the number of arguments, hence the following example is correct as

per the restrictions on the dimensions, albeit it yields a nonconvex constraint.

coeff_pre = np.random.random (6,3,7)

x = np.array ([xp.var () for i in range(140)]).reshape (4,7,5)

y = np.array ([xp.var () for i in range(80)]).reshape (2,5,8)

coeff_post = np.random.random (6,8,7)

p.addConstraint (xp.Dot (coeff_pre, x, y, coeff_post) >= 0)

Similar to the NumPy dot product, the Xpress dot product has an out parameter for deﬁning the

output in which to store the product.

The following script deﬁnes two constraints: the ﬁrst restricts the squared norm ||z|| = z · z of the

vector z of variables to be at most one. It does so by applying the dot operator on the vector

itself. The second constraint (t − z)

Q(t − z) ≤ 1 restricts the quadratic form on the left-hand side

to be at most 1.

p.addConstraint (xp.Dot (z,z) <= 1) # restrict norm of z to 1

Q = np.random.random (N,N) # create a random 20x20 matrix

p.addConstraint (xp.Dot ((t-z), Q, (t-z)) <= 1)

As for the Sum operator, when handling variables or expressions, it is advised to use the Dot

operator in the Xpress module rather than the native Python operator, for reasons of efﬁciency.

Fair Isaac Corporation Conﬁdential and Proprietary Information 13

CHAPTER 4

Controls and Attributes

A control is a parameter that can inﬂuence the performance and behavior of the Xpress

Optimizer. For example, the MIP gap, the feasibility tolerance, or the type of root LP algorithms

are controls that can be set. Controls can both be read from and written to an optimization

problem.

An attribute is a feature of an optimization problem, such as the number of rows and columns or

the number of quadratic elements of the objective function. They are read-only parameters in

that they can only be modiﬁed by functions for adding constraints or variables, or functions for

setting and modifying the objective function.

Both controls and attributes are of three types: integer, ﬂoating point, or string. The Xpress

Python interface allows for setting and retrieving the value of all controls of an optimization

problem, as well as getting the value of all of a problem’s attributes.

Following Python’s philosophy, one can set and obtain multiple controls/attributes with one

function call. In other words, one can set either (i) a single control and its value; or (ii) a Python

dictionary coupling a list of control names and their respective value. Similarly, with one function

call one can obtain (i) the value of a single attribute or control by specifying it as a parameter; or

(ii) a dictionary associating names to values for each of a list of controls or attributes given as an

argument. See the examples below for more information.

4.1 Controls

Use the method setControl to set the value of one or more controls. Its synopsis is as follows:

setControl (ctrl, value)

setControl ({ctrl1: value1, ctrl2: value2, ..., ctrlk: valuek})

The ﬁrst form is for setting the value of the control ctrl to value. The second form is for setting

ctrl1 to value1, ctrl2 to value2, ..., and ctrlk to valuek.

A list of all controls can be found on the Xpress Optimizer’s reference manual. The control

parameters to be passed in setControl are lower-case strings:

p.setControl (’miprelstop’, 1e-9)

p.setControl ({’miprelstop’: 1e-3, ’feastol’: 1e-6})

Use the method getControl to retrieve the value of one or more controls. Its synopsis is one of

the following:

getControl (ctrl)

getControl ([ctrl1, ctrl2, ..., ctrlk])

getControl (ctrl1, ctrl2, ..., ctrlk)

getControl ()

Fair Isaac Corporation Conﬁdential and Proprietary Information 14

Controls and Attributes

The ﬁrst form is for obtaining the value of the control ctrl. The output will be the value of the

control. The second and third forms are for retrieving ctrl1 , ctrl2 , ..., and ctrlk. Whether the

controls are declared in a list or a tuple does not matter. The result will be a dictionary coupling

each control with its value. The last form is to obtain all controls; the result is a dictionary

coupling all controls with their respective value.

The control parameters to be passed in getControl are lower-case strings. For a problem p the call

will be as follows:

mrs = p.getControl (’miprelstop’)

someattr = p.getControl (’miprelstop’, ’feastol’)

4.2 Examples

import xpress as xp

p = xp.problem ()

p.setControl ({’miprelstop’: 1e-5, ’feastol’: 1e-4})

p.setControl (’miprelstop’, 1e-5)

print (p.getControl (’miprelstop’) ) # print the current value of miprelstop

print (p.getControl (’maxtime’, ’feastol’)) # print a dictionary with the current

# value of miprelstop and feastol

print (p.getControl ([’presolve’, ’miplog’])) # Same output

print (p.getControl ()) # print a dictionary with ALL control

# initialize a dictionary with two controls and their value. Then

# change their value conditionally and set their new (possibly

# changed) value

myctrl = p.getControl ([’miprelstop’, ’feastol’])

if (myctrl[’miprelstop’] <= 1e-4):

myctrl[’miprelstop’] = 1e-3;

myctrl[’feastol’] = 1e-3;

else:

myctrl[’feastol’] = 1e-4;

p.setControl (myctrl)

4.3 Attributes

Use the method getAttrib to retrieve the value of one or more controls. Its synopsis is one of the

following:

getAttrib (attr)

getAttrib ([attr1, attr2, ..., attrk])

getAttrib (attr1, attr2, ..., attrk)

getAttrib ()

The ﬁrst form is for obtaining the value of the attribute attr. The output will be the value of the

attribute. The second and third forms are for retrieving attr1 , attr2 , ..., and attrk. Whether the

attributes are declared in a list or a tuple does not matter. The result will be a dictionary coupling

each attribute with its value. The last form is to obtain all attributes; the result is a dictionary

coupling all attributes with their respective value.

A list of all attributes can be found on the Xpress Optimizer’s reference manual. As for controls,

the attribute parameters to be passed in getAttrib are lower-case strings. For a problem p the

call will be as follows:

Fair Isaac Corporation Conﬁdential and Proprietary Information 15

Controls and Attributes

nrows = p.getAttrib (’nrow’)

problemsize = p.getAttrib (’nrow’, ’ncol’)

4.4 Examples

import xpress as xp

p = xp.problem ()

p.read ("example.lp")

print ("The problem has ",

p.getAttrib (’nrow’), "rows and",

p.getAttrib (’ncol’), "columns")

# Obtain dictionary with two entries: the number of rows and

# columns of the problem read

print (p.getAttrib ([’nrow’, ’ncol’]))

# produce a Python dictionary with all attributes of problem m, and

# hence of LP file example.lp

attributes = p.getAttrib ()

4.5 Accessing controls and attributes as object members

An alternative, more "prompt-friendly" way to get controls and attributes is through their direct

access in a problem or, in the case of controls, the Xpress module itself.

The Xpress module has an object, called controls, containing all controls of the Optimizer. Upon

importing the Xpress module, these controls are initialized at their default value. The user can

obtain their value at any point and can also set their value; this new value will be inherited by all

problems created after the modiﬁcation. They can be read and written as follows:

xpress.controls.<controlname>

xpress.controls.<controlname> = <new value>

For example, the object xpress.controls.miprelstop contains the value of the control

miprelstop. Controls can be read (and, for example, printed) and set as follows:

import xpress as xp

print (xp.controls.heurstrategy)

xp.controls.feastol = 1e-4 # Set new default to 1e-4

These "global" controls are maintained throughout while the Xpress module is loaded. Note that

the controls object of the Xpress module does not refer to any speciﬁc problem.

In addition, every problem has a controls object that stores the controls related to the problem

itself. This is the object the functions getControl and setControl refer to. Similar to the Xpress

module’s controls object, all members of a problem’s object can be read and written. For a

problem p, the following shows how to read and write a problem’s control:

p.controls.<controlname>

p.controls.<controlname> = <new value>

A problem’s controls are independent of the global controls object of the Xpress module.

However, when a new problem is created its controls are copied from the current values in the

Fair Isaac Corporation Conﬁdential and Proprietary Information 16

Controls and Attributes

global object. Note that after creating a new problem, changing the members in

xpress.controls does not affect the problem’s controls. The following examples should clarify

this:

import xpress as xp

# create a new problem whose MIPRELSTOP is ten times smaller

# than the default value

p1 = xp.problem ("problem1")

p1.controls.miprelstop = 0.1 * xp.controls.miprelstop

p1.controls.feastol = 1e-5

p1.read ("example1.lp")

xp.controls.miprelstop = 1e-8 # Set new default

# The new problem will have a MIPRELSTOP of 1e-8

p2 = xp.problem ("problem2")

p2.read ("example2.lp")

# The next problem has a less restrictive feasibility tolerance

# (i.e. 1e-6) than problem 2

p2v = xp.problem ("problem2 variant")

p2v.read ("example2.lp")

p2v.controls.feastol = 100 * p2.controls.feastol

p1.solve ()

p2.solve ()

p2v.solve () # solve "example2.lp" with a less restrictive

# feasibility tolerance

Attributes can be handled similar as above through a member of the class problem, called

attributes, with two exceptions: ﬁrst, there is no "global" attribute object, as a set of attributes

only makes sense when associated with a problem; second, an attribute cannot be set.

Once a problem p has been created (or read from a ﬁle), its attributes are available as

p.attribute.attribute_name. The example in the previous section can be modiﬁed as follows:

import xpress as xp

p = xp.problem ()

p.read ("example.lp")

print ("The problem has ",

p.attributes.nrow, "rows and ",

p.attributes.ncol, "columns")

When using the Python prompt in creating problems with the Xpress module, the name of

controls and attributes can be auto-completed by pressing TAB (note: this only works in Python

3.4 and subsequent versions). For instance,

>>> import xpress

>>> p = xp.problem ()

>>> p.read ("example.lp")

>>> p.attributes.n<TAB>

p.attributes.namelength p.attributes.nodedepth p.attributes.nodes p.attributes.numiis

>>> p.attributes.nodedepth

>>> p.attributes.ma<TAB>

p.attributes.matrixname p.attributes.maxabsdualinfeas

p.attributes.maxabsprimalinfeas p.attributes.maxprobnamelength

p.attributes.maxreldualinfeas p.attributes.maxrelprimalinfeas

>>> p.attributes.matrixname

’noname’

>>>>> xp.controls.o<TAB>

Fair Isaac Corporation Conﬁdential and Proprietary Information 17

Controls and Attributes

xp.controls.oldnames xp.controls.omniformat

xp.controls.optimalitytol xp.controls.optimalitytoltarget

xp.controls.outputlog xp.controls.outputmask

xp.controls.outputtol

>>> xp.controls.omniformat

Fair Isaac Corporation Conﬁdential and Proprietary Information 18

CHAPTER 5

Using Callbacks

This chapter shows how to deﬁne and use callback functions from the Xpress Python interface.

The design of this part of the interface reﬂects as closely as possible the design of the callback

functions deﬁned in the C API of the Xpress Optimizer.

5.1 Introduction

Callback functions are a useful tool for adapting the Xpress Optimizer to the solution of various

classes of problems, in particular Mixed Integer Programming (MIP) problems, both with linear or

nonlinear constraints. Their main purpose is to provide the user with a point of entry into the

branch-and-bound, which is the workhorse algorithm for MIPs.

Using callback function is simple: the user ﬁrst deﬁnes a function (say myfunction) that is to be

run every time the branch-and-bound reaches a well-speciﬁed point; second, the user calls a

function (such as addcbpreintsol) with myfunction as its argument. Finally, the user runs the

solve command that launches the branch-and-bound, the simplex solver, or the barrier solver; it

is while these are run that myfunction is called.

A callback function, hence, is passed once as an argument and used possibly many times. It is

called while a solver is running, and it is passed the following:

 a problem object (of the same class as an object declared with p = xpress.problem()); and

 a data object.

The data object is user-deﬁned and is given to the problem when adding the callback function. It

can be used to store information that the user can read and/or modify within the callback. For

instance, the following code shows how to add a callback function, preintsolcb that is called

every time a new integer solution is found.

import xpress as xp

class foo:

"Simple class"

bar = 0

def __init__ (self):

self.bar = 1

def update (self):

self.bar += 1

def preintsolcb (prob, data, isheuristic, cutoff):

"""

Callback to be used when an integer solution is found. The

"data" parameter is of class foo

"""

Fair Isaac Corporation Conﬁdential and Proprietary Information 19

Using Callbacks

p = xp.problem ()

p.read (’myprob.lp’) # reads in a problem, let’s say a MIP

baz = foo ()

p.addcbpreintsol (preintsolcb, baz, 3)

p.solve ()

While the function argument is necessary for all addcb* functions, the data object can be

speciﬁed as None. In that case, the callback will be run with None as its data argument. The call

also speciﬁes a priority with which the callback should be called: the larger the (positive) priority,

the more urgently it is called.

Any call to an addcb* function, as the names imply, only adds a function to a list of callback

functions for that speciﬁc point of the BB algorithm. For instance, two calls to addcbpreintsol

with two functions preint1 and preint2, respectively with priority 3 and 5, puts the two

functions in a list. The two functions will be called (preint2 ﬁrst) whenever the BB algorithm

ﬁnds an integer solution.

In order to remove a callback function that was added with addcb*, a corresponding removecb*

function is provided, for instance removecbpreintsol. This function takes two arguments, i.e., the

callback function and the data object, and deletes all elements of the list of callbacks that were

added with the corresponding addcb function that match the function and the data.

The None keyword acts as a wildcard that matches any function/data object: if removecb* is called

with None as the function, then all callbacks matching the data will be deleted. If the data is also

None, all callback functions of that type are deleted; this can be obtained by passing no argument

to removecb*.

The arguments and return value of the callback functions reﬂect those in the C API, and this holds

for parameter names as well. As for the other API functions of the Python interface, there are a

few exceptions:

 If a function in the C API requires a parameter n to indicate the size of an array argument to

follow, n is not required in the corresponding Python function;

 If a function in the C API uses passing by reference as a means to allow for modifying a

value and returning it as an output, the Python counterpart will have this as the return

value of the function. Where multiple output values are comprised in the list of parameters,

the return value is a tuple composed of the returned values. Elements of this tuple can be

None if no change was made to that output value.

Most callback functions refer to a problem, therefore the addcb* method is called from a problem

object. The only exception is the function xpress.addcbmsghandler(), which is called on the

Xpress module itself and allows for providing a function that is called every time any output is

produced within the Optimizer.

We refer to the Reference chapter of this manual for all information regarding callback functions

and how to add/remove them from a problem.

Fair Isaac Corporation Conﬁdential and Proprietary Information 20

CHAPTER 6

Examples of use

This chapter discusses some example Python scripts that are part of the Xpress Optimizer’s Python

interface. Most of them are well commented so the user can refer directly to the source for

guidance.

Most of these scripts have an initial part in common, which we reproduce here but omit in all

explanations below for compactness. These initial lines import the Xpress module itself and the

NumPy module, which is used in some of the examples. The last line is to make the print

statements, which are in Python 3 style here, work in Python 2.7 as well.

import xpress as xp

import numpy as np

from __future__ import print_function

6.1 Creating simple problems

Below are a few examples on how to create simple LP, MIP, MIQP, and similar problems. Note that

they make use of API functions that resemble the C API functions for creating problems, and are

used similarly here.

6.1.1 Generating a small Linear Programming problem

In this example, we create a problem and load a matrix of coefﬁcients, a rhs, and an objective

coefﬁcient vector with the loadproblem function. We also assign names to both rows and

columns (both are optional). These data correspond to the following problem with three

variables and four constraints:

minimize: 3 x

+ 4 x

+ 5 x

subject to: x

+ x

≥ -2.4

+ 3x

≥ -3

+ 3x

= 4

+ x

≤ 5

-1 ≤ x

≤ 3

-1 ≤ x

≤ 5

-1 ≤ x

≤ 8

p = xp.problem ()

p.loadproblem ("", # probname

[’G’,’G’,’E’, ’L’], # qrtypes

[-2.4, -3, 4, 5], # rhs

Fair Isaac Corporation Conﬁdential and Proprietary Information 21

Examples of use

None, # range

[3,4,5], # obj

[0,2,4,8], # mstart

None, # mnel

[0,1,2,3,0,1,2,3], # mrwind

[1,2,2,1,1,3,3,1], # dmatval

[-1,-1,-1], # lb

[3,5,8], # ub

colnames = [’X1’,’X2’,’X3’], # column names

rownames = [’row1’,’row2’,’row3’,’constr_04’]) # row names

p.write ("loadlp", "lp")

p.solve ()

We then create another variable and add it to the problem, then modify the objective function.

Note that the objective function is replaced by, not amended with, the new expression. After

solving the problem, it saves it into a ﬁle called update.lp.

x = xp.var()

p.addVariable (x)

p.setObjective (x**2 + 2*x + 444)

p.solve()

p.write ("updated", "lp")

6.1.2 A Mixed Integer Linear Programming problem

This example uses loadproblem to create a Mixed Integer Quadratically Constrained Quadratic

Programming problem with two Special Ordered Sets. Note that data that is not needed is simply

set as None.

The Examples directory provides similar examples for different types of problems.

p = xp.problem ()

p.loadproblem ("", # probname

[’G’,’G’,’L’, ’L’], # qrtypes

[-2.4, -3, 4, 5], # rhs

None, # range

[3,4,5], # obj

[0,2,4,8], # mstart

None, # mnel

[0,1,2,3,0,1,2,3], # mrwind

[1,1,1,1,1,1,1,1], # dmatval

[-1,-1,-1], # lb

[3,5,8], # ub

[0,0,0,1,1,2], # mqobj1

[0,1,2,1,2,2], # mqobj1

[2,1,1,2,1,2], # dqe

[2,3], # qcrows

[2,3], # qcnquads

[1,2,0,0,2], # qcmqcol1

[1,2,0,2,2], # qcmqcol2

[3,4,1,1,1], # qcdqval

[’I’,’S’], # qgtype

[0,1], # mgcols

[0,2], # dlim

[’1’,’1’], # qstype

[0,2,4], # msstart

[0,1,0,2], # mscols

[1.1,1.2,1.3,1.4]) # dref

p.solve ()

Fair Isaac Corporation Conﬁdential and Proprietary Information 22

Examples of use

6.2 Modeling examples

6.2.1 A simple model

This example demonstrates how variables and constraints, or arrays thereof, can be added into a

problem. The script then prints the solution and all attributes/controls of the problem.

N = 4

S = range (N)

v = [xp.var (name = "y{0}".format (i)) for i in S] # set name of a variable as

m = xp.problem ()

v1 = xp.var (name = "v1", lb=0, ub=10, threshold=5, vartype = xp.continuous)

v2 = xp.var (name = "v2", lb=1, ub=7, threshold=3, vartype = xp.continuous)

vb = xp.var (name = "vb", vartype = xp.binary)

# Create a variable with name yi, where i is an index in S

v = [xp.var (name = "y{0}".format (i), lb = 0, ub = 2*N) for i in S]

The call below adds both v, a vector (list) of variables, and v1 and v2, two scalar variables.

m.addVariable (vb, v, v1, v2)

c1 = v1 + v2 >= 5

m.addConstraint (c1, # Adds a list of constraints: three single constraints...

2*v1 + 3*v2 >= 5,

v[0] + v[2] >= 1,

# ... and a set of constraints indexed by all {i in

# S: i<N-1} (recall that ranges in Python are from 0

# to n-1)

(v[i+1] >= v[i] + 1 for i in S if i < N-1))

# objective overwritten at each setObjective ()

m.setObjective (xp.Sum ([i*v[i] for i in S]), sense = xp.minimize)

m.solve ()

print ("status: ", m.getProbStatus ())

print ("string: ", m.getProbStatusString ())

print ("solution:", m.getSolution ())

6.2.2 Using IIS to investigate an infeasible problem

The problem modeled below is infeasible,

x0 = xp.var()

x1 = xp.var()

x2 = xp.var(vartype = xp.binary)

c1 = x0 + 2 * x1 >= 1

c2 = 2 * x0 + x1 >= 1

c3 = x0 + x1 <= .5

c4 = 2 * x0 + 3 * x1 >= 0.1

The three constraints c1, c2, and c3 above are incompatible as can be easily veriﬁed. Adding all of

them to a problem will make it infeasible. We use the functions to retrieve the Irreducible

Infeasible Subsystems (IIS).

Fair Isaac Corporation Conﬁdential and Proprietary Information 23

Examples of use

minf = xp.problem ("ex-infeas")

minf.addVariable (x0,x1,x2)

minf.addConstraint (c1,c2,c3,c4)

minf.solve()

minf.iisall()

print ("there are ", minf.attributes.numiis, " iis’s")

miisrow = []

miiscol = []

constrainttype = []

colbndtype = []

duals = []

rdcs = []

isolationrows = []

isolationcols = []

# get data for the first IIS

minf.getiisdata (1, miisrow, miiscol, constrainttype, colbndtype,

duals, rdcs, isolationrows, isolationcols)

print ("iis data:", miisrow, miiscol, constrainttype, colbndtype,

duals, rdcs, isolationrows, isolationcols)

# Another way to check IIS isolations

print ("iis isolations:", minf.iisisolations (1))

rowsizes = []

colsizes = []

suminfeas = []

numinfeas = []

print ("iisstatus:", minf.iisstatus (rowsizes, colsizes, suminfeas, numinfeas))

print ("vectors:", rowsizes, colsizes, suminfeas, numinfeas)

6.2.3 Modeling a problem using Python lists and vectors

We create a convex QCQP problem. We use a vector of N=5 variables and sets constraints and

objective. We deﬁne all constraints and the objective function using a Python aggregate type.

N = 5

S = range (N)

v = [xp.var (name = "y{0}".format (i)) for i in S]

m = xp.problem ("problem 1")

print ("variable:", v)

m.addVariable (v)

m.addConstraint (v[i] + v[j] >= 1 for i in range (N-4) for j in range (i,i+4))

m.addConstraint (xp.Sum([v[i]**2 for i in range (N-1)]) <= N**2 * v[N-1]**2)

m.setObjective (xp.Sum ([i*v[i] for i in S]) * (xp.Sum ([i*v[i] for i in S])))

m.solve ()

print ("solution: ", m.getSolution ())

6.2.4 A knapsack problem

Here follows an example of a knapsack problem formulated using lists of numbers. All data in the

problem are lists, and so are the variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 24

Examples of use

S = range (5) # that’s the set {0,1,2,3,4}

value = [102, 512, 218, 332, 41] # or just read them from file

weight = [ 21, 98, 44, 59, 9]

x = [xp.var (vartype = xp.binary) for i in S]

profit = xp.Sum (value[i] * x[i] for i in S)

p = xp.problem ("knapsack")

p.addVariable (x)

p.addConstraint (xp.Sum (weight[i] * x[i] for i in S) <= 130)

p.setObjective (profit, sense = xp.maximize)

p.solve ()

Note that the same result could have been achieved using NumPy arrays and the Xpress module’s

dot product as follows:

value = np.array ([102, 512, 218, 332, 41])

weight = np.array ([ 21, 98, 44, 59, 9])

x = np.array ([xp.var (vartype = xp.binary) for i in S])

profit = xp.Dot (value, x)

p = xp.problem ("knapsack")

p.addVariable (x)

p.addConstraint (xp.Dot (weight, x) <= 130)

p.setObjective (profit, sense = xp.maximize)

p.solve ()

6.2.5 A Min-cost-ﬂow problem using NumPy

This example solves a min-cost-ﬂow problem using NumPy and the incidence matrix of the graph.

It uses the networkx package, which might have to be installed using, for example, pip.

import networkx as netx

# digraph definition

V = [1,2,3,4,5] # vertices

E = [[1,2], [1,4], [2,3], [3,4], [4,5], [5,1]] # arcs

n = len (V) # number of nodes

m = len (E) # number of arcs

G = netx.DiGraph (E)

# Get NumPy representation

A = (netx.incidence_matrix (G, oriented = True).toarray())

We use NumPy vectors and the Xpress interface’s dot product, the xpress.Dot operator. Note that

although NumPy has a dot operator, especially for large models it is strongly advised to use the

Xpress interface’s Dot function for reasons of efﬁciency.

demand = np.array ([3, -5, 7, -2, -3])

cost = np.array ([23, 62, 90, 5, 6, 8])

flow = np.array ([xp.var () for i in E]) # flow variables declared on arcs

p = xp.problem (’network flow’)

p.addVariable (flow)

p.addConstraint (xp.Dot (A, flow) == - demand)

p.setObjective (xp.Dot (cost, flow))

p.solve ()

Fair Isaac Corporation Conﬁdential and Proprietary Information 25

Examples of use

for i in range (m):

print (’flow on’, E[i], ’:’, p.getSolution (flow [i]))

6.2.6 A nonlinear model

Let’s solve a classical nonlinear problem: ﬁnding the minimum of the Rosenbrock function. For

parameters a and b, minimize (a − x )

+ b(y − x

)

a,b = 1,100

x = xp.var (lb = -xp.infinity)

y = xp.var (lb = -xp.infinity)

p = xp.problem ()

p.addVariable (x,y)

p.setObjective ((a-x)**2 + b*(y-x**2)**2)

p.controls.xslp_solver = 0 # solve it with SLP, not Knitro

p.solve ()

print ("status: ", p.getProbStatus ())

print ("string: ", p.getProbStatusString ())

print ("solution:", p.getSolution ())

6.2.7 Finding the maximum-area n-gon

The problem asks, given n, to ﬁnd the n-sided polygon of largest area inscribed in the unit circle.

While it is natural to prove that all vertices of a global optimum reside on the unit circle, the

problem is formulated so that every vertex i is at distance rho

from the center, and at angle

theta

. We would expect that the local optimum found has all rho’s are equal to 1. The example

ﬁle contains instructions for drawing the resulting polygon using matplotlib.

The objective function is the total area of the polygon. Considering the segment S[i] joining the

center to the i-th vertex and A(i,j) the area of the triangle deﬁned by the two segments S[i] and

S[j], the objective function is A

(0,1)

+ A

(1,2)

+. . . +A

(N−1,0)

, where

(i,j)

= 1 / 2 ∗ rho

∗ rho

∗ sin(theta

− theta

). We ﬁrst deﬁne the set Vertices as the set of integers

from 0 to n − 1.

rho = [xp.var (lb = 1e-5, ub = 1.0) for i in Vertices]

theta = [xp.var (lb = -math.pi, ub = math.pi) for i in Vertices]

p = xp.problem ()

p.addVariable (rho, theta)

p.setObjective (

0.5*(xp.Sum (rho[i]*rho[i-1]*xp.sin (theta[i]-theta[i-1]) for i in Vertices if i != 0)

+ rho[0]*rho[N-1]*xp.sin (theta[0]-theta[N-1])), sense = xp.maximize)

We establish that the angles must be increasing in order to obtain a sensible solution:

p.addConstraint (theta[i] >= theta[i-1] + 1e-4 for i in Vertices if i != 0)

Note also that we enforce that the angles be different as otherwise they might form a local

optimum where all of them are equal.

Fair Isaac Corporation Conﬁdential and Proprietary Information 26

Examples of use

6.2.8 Solving the n-queens problem

In chess, the queen can move in all directions (even diagonally) and travel any distance. The

problem of the n queens consists in placing n queens on an n × n chessboard so that none of

them can be eaten in one move.

We ﬁrst create a dictionary of variables, mapping each cell of the chessboard to one variable so

that we can refer to it later. All variables are clearly binary as they indicate whether a given cell

has a queen or not.

n = 10 # the size of the chessboard

N = range (n)

x = {(i,j): xp.var (vartype = xp.binary, name=’q{0}{1}’.format (i,j))

for i in N for j in N}

vertical = [xp.Sum (x[i,j] for i in N) <= 1 for j in N]

horizontal = [xp.Sum (x[i,j] for j in N) <= 1 for i in N]

diagonal1 = [xp.Sum (x[i,j] for j in N for i in N if i+j == k) <= 1

for k in range (1,2*n-2)]

diagonal2 = [xp.Sum (x[i,j] for j in N for i in N if i-j == k) <= 1

for k in range (2-n,n-1)]

p = xp.problem()

p.addVariable (x)

p.addConstraint (vertical, horizontal, diagonal1, diagonal2)

# Objective, to be maximized: number of queens on the chessboard

p.setObjective (xp.Sum (x), sense = xp.maximize)

p.solve ()

As a rudimentary form of visualization, we print the solution on the chessboard with different

symbols for variables at one or zero.

for i in N:

for j in N:

if p.getSolution (x[i,j]) == 1:

print (’@’, sep=’’, end=’’)

else:

print (’.’, sep=’’, end=’’)

print (’’)

6.2.9 Solving Sudoku problems

The well-known Sudoku puzzles ask one to place numbers from 1 to 9 into a 9 × 9 grid such that

no number repeats in any row, in any column, and in any 3x3 sub-grid. For a more general

version of the game, replace 3 with q and 9 with q

We model this problem as an assignment problem where certain conditions must be met for all

numbers in the columns, rows, and sub-grids.

These subgrids are lists of tuples with the coordinates of each subgrid. In a 9 × 9 sudoku, for

instance, subgrids[0,1] has the 9 elements in the middle top square.

The input is a starting grid where the unknown numbers are replaced by zero. The example ﬁle

contains a relatively hard 9 × 9 sudoku, which we show below, and also a 16 × 16 variant of the

same game.

q = 3

starting_grid = \

Fair Isaac Corporation Conﬁdential and Proprietary Information 27

Examples of use

[[8,0,0,0,0,0,0,0,0],

[0,0,3,6,0,0,0,0,0],

[0,7,0,0,9,0,2,0,0],

[0,5,0,0,0,7,0,0,0],

[0,0,0,0,4,5,7,0,0],

[0,0,0,1,0,0,0,3,0],

[0,0,1,0,0,0,0,6,8],

[0,0,8,5,0,0,0,1,0],

[0,9,0,0,0,0,4,0,0]]

n = q**2 # the size must be the square of the size of the subgrids

N = range (n)

x = {(i,j,k): xp.var (vartype = xp.binary, name=’x{0}_{1}_{2}’.format(i,j,k))

for i in N for j in N for k in N}

# define all q^2 subgrids

subgrids = {(h,l): [(i,j) for i in range (q*h, q*h + q)

for j in range (q*l, q*l + q)]

for h in range (q) for l in range (q)}

vertical = [xp.Sum (x[i,j,k] for i in N) == 1 for j in N for k in N]

horizontal = [xp.Sum (x[i,j,k] for j in N) == 1 for i in N for k in N]

subgrid = [xp.Sum (x[i,j,k] for (i,j) in subgrids[h,l]) == 1

for (h,l) in subgrids.keys() for k in N]

# Assign exactly one number to each cell

assign = [xp.Sum (x[i,j,k] for k in N) == 1 for i in N for j in N]

Then we ﬁx those variables that are non-zero in the input grid. We don’t need an objective

function as this is a feasibility problem. After computing the solution, we print it to the screen.

init = [x[i,j,k] == 1 for k in N for i in N for j in N

if starting_grid[i][j] == k+1]

p = xp.problem()

p.addVariable (x)

p.addConstraint (vertical, horizontal, subgrid, assign, init)

p.solve ()

print (’Solution:’)

for i in N:

for j in N:

l = [k for k in N if p.getSolution (x[i,j,k]) >= 0.5]

assert (len (l) == 1)

print (’{0:2d}’.format (1 + l[0]), end = ’’, sep=’’)

print (’’)

6.3 Examples using NumPy

6.3.1 Using NumPy multidimensional arrays to create variables

Use NumPy arrays for creating a 3-dimensional array of variables, then use it to create a mode.

S1 = range (2)

S2 = range (3)

S3 = range (4)

m = xp.problem ()

Fair Isaac Corporation Conﬁdential and Proprietary Information 28

Examples of use

h = np.array ([[[xp.var (vartype = xp.binary)

for i in S1]

for j in S2]

for k in S3])

m.addVariable (h)

m.setObjective (h[0][0][0] * h[0][0][0] +

h[1][0][0] * h[0][0][0] +

h[1][0][0] * h[1][0][0] +

xp.Sum (h[i][j][k] for i in S3 for j in S2 for k in S1))

cons00 = - h[0][0][0] ** 2 +

xp.Sum (i * j * k * h[i][j][k]for i in S3 for j in S2 for k in S1) >= 11

m.addConstraint (cons00)

m.solve ()

The ﬁnal part of the code retrieves the matrix representation of the quadratic part of the only

constraint.

mstart1=[]

mclind1=[]

dqe1=[]

m.getqrowqmatrix (cons00, mstart1, mclind1, dqe1, 29, h[0][0][0], h[3][2][1])

print ("row 0:", mstart1, mclind1, dqe1)

6.3.2 Using the dot product to create arrays of expressions

Here we use NumPy arrays to print the product of a matrix by a random vector, and the

xpress.Dot function on a matrix and a vector. Note that the NumPy dot operator works perfectly

ﬁne here, but should be avoided for reasons of performance, especially when handling large

arrays where at least one contains optimization variables or expressions.

x = np.array ([xp.var() for i in range(5)])

p = xp.problem ()

p.addVariable (x)

p.addConstraint (xp.Sum (x) >= 2)

p.setObjective (xp.Sum (x[i]**2 for i in range (5)))

p.solve()

A = np.array (range(30)).reshape(6,5) # A is a 6x5 matrix

sol = np.array (p.getSolution ()) # a vector of size 5

columns = A*sol # not a matrix-vector product!

v = np.dot (A,sol) # an array: matrix-vector product A*sol

w = xp.Dot (A,x) # an array of expressions

print (v,w)

6.3.3 Using the Dot product to create constraints and quadratic functions

This is an example of a problem formulation that uses the xpress.Dot operator to formulate

constraints in a concise fashion. Note that the NumPy dot operator is not suitable here as the

result is an expression in the Xpress variables.

A = np.random.random(30).reshape(6,5) # A is a 6x5 matrix

Q = np.random.random(25).reshape(5,5) # Q is a 5x5 matrix

x = np.array ([xp.var() for i in range(5)]) # vector of variables

x0 = np.random.random (5) # random vector

Fair Isaac Corporation Conﬁdential and Proprietary Information 29

Examples of use

Q += 4 * np.eye (5) # add 5 * the identity matrix

Lin_sys = xp.Dot (A,x) <= np.array([3,4,1,4,8,7]) # 6 constraints (rows of A)

Conv_c = xp.Dot (x,Q,x) <= 1 # one quadratic constraint

p = xp.problem ()

p.addVariable (x)

p.addConstraint (Lin_sys, Conv_c)

p.setObjective (xp.Dot (x-x0, x-x0)) # minimize distance from x0

p.solve ()

6.3.4 Using NumPy to create quadratic optimization problems

This example creates and solves a simple quadratic optimization problem. Given an n × n matrix

Q and a point x

, minimize the quadratic function x

(Q + n

I)x subject to the linear system

(x − x

)

Q + e = 0, where e is the vector of all ones, the inequalities Qx ≥ 0, and nonnegativity on

all variables. Report solution if available.

n = 10

Q = np.arange (1, n**2 + 1).reshape (n, n)

x = np.array ([xp.var () for i in range (n)])

x0 = np.random.random (n)

p = xp.problem ()

p.addVariable (x)

c1 = xp.Dot ((x - x0), Q) + 1 == 0

c2 = xp.Dot (Q, x) >= 0

p.addConstraint (c1,c2)

p.setObjective (xp.Dot (x, Q + N**3 * np.eye (N), x))

p.solve (’’)

print ("nrows, ncols:", p.attributes.rows, p.attributes.cols)

print ("solution:", p.getSolution ())

p.write ("test5-qp", "lp")

6.4 Advanced examples: callbacks and problem querying/modifying

6.4.1 Visualize the branch-and-bound tree of a problem

This example shows how to visualize the BB tree of a problem after (partially) solving it. It is

assumed here that all branches are binary.

We ﬁrst deﬁne a recursive function that computes the cardinality of a subtree rooted at a node i.

This is necessary as the visualization of the BB tree is more balanced when the subtree size is

taken into account. The card_subtree array, which is ﬁlled here, is used then for computing the

width of each visualized subtree.

import networkx as netx

from matplotlib import pyplot as plt

def postorder_count (node):

"""

Recursively count nodes to compute the cardinality of a subtree for

Fair Isaac Corporation Conﬁdential and Proprietary Information 30

Examples of use

each node

"""

card = 0

if node in left.keys (): # see if node has a left key

postorder_count (left [node])

card += card_subtree [left [node]]

if node in right.keys ():

postorder_count (right [node])

card += card_subtree [right [node]]

card_subtree [node] = 1 + card

We also deﬁne a function that determines the position of each node depending on the

cardinality of the subtree rooted at the node.

def setpos (T, node, curpos, st_width, depth):

"""

Set position depending on cardinality of each subtree

"""

# Special condition: we are at the root

if node == 1:

T.add_node (node, pos = (0.5, 1))

alpha = .1 # use a convex combination of subtree comparison and

# depth to assign a width to each subtree

if node in left.keys ():

# X position in the graph should not just depend on depth,

# otherwise we’d see a long and thin subtree and it would just

# look like a path

leftwidth = st_width * (alpha * .5 + (1 - alpha) * card_subtree [left [node]]

/ card_subtree [node])

leftpos = curpos - (st_width - leftwidth) / 2

T.add_node (left [node], pos = (leftpos, - depth))

T.add_edge (node, left [node])

setpos (T, left [node], leftpos, leftwidth, depth + 1)

if node in right.keys ():

rightwidth = st_width * (alpha * .5 + (1 - alpha) * card_subtree [right [node]]

/ card_subtree [node])

rightpos = curpos + (st_width - rightwidth) / 2

T.add_node (right [node], pos = (rightpos, - depth))

T.add_edge (node, right [node])

setpos (T, right [node], rightpos, rightwidth, depth + 1)

This is the only operation we need to be carried out at every node: given a node number,

newnode, and its parent, parent, we store the information in the left and right arrays so that at

the end of the BB we have an explicit BB tree stored in these arrays.

def storeBBnode (prob, Tree, parent, newnode, branch):

# Tree is the callback data, and it’s equal to T

if branch == 0:

left [parent] = newnode

else:

right [parent] = newnode

Fair Isaac Corporation Conﬁdential and Proprietary Information 31

Examples of use

We now set up the BB tree data and create a problem. We read it from a local ﬁle, but any user

problem can be read and analyzed. We set the node callback with addcbnewnode so that we can

collect information at each new node.

T = nx.Graph ()

left = {}

right = {}

card_subtree = {}

pos = {}

p = xp.problem ()

p.read (’sampleprob.mps.gz’)

p.addcbnewnode (storeBBnode, T, 100)

p.controls.maxnode=40000 # Limit the number of nodes inserted in the graph

p.solve ()

postorder_count (1) # assign card_subtree to each node

setpos (T, 1, 0.5, 1, 0) # determine the position of each node

# depending on subtree cardinalities

pos = nx.get_node_attributes (T, ’pos’)

nx.draw (T, pos) # create BB tree representation

plt.show () # display it; you can zoom indefinitely and see all subtrees

6.4.2 Query and modify a simple problem

This example shows how to change an optimization problem using the Xpress Python interface.

x = xp.var ()

y = xp.var ()

cons1 = x + y >= 2

upperlim = 2*x + y <= 3

p = xp.problem ()

p.addVariable (x,y)

p.setObjective ((x-4)**2 + (y-1)**2)

p.addConstraint (cons1, upperlim)

p.write (’original’, ’lp’)

After saving the problem to a ﬁle, we change two of its coefﬁcients. Note that the same

operations can be carried out with a single call to p.chgmcoef ([cons1,1],[x,0],[3,4]).

p.chgcoef (cons1, x, 3) # coefficient of x in cons1 becomes 3

p.chgcoef (1, 0, 4) # coefficient of y in upperlim becomes 4

p.write (’changed’, ’lp’)

6.4.3 Change a problem after solution

Construct a problem using addVariable and addConstraint, then use the Xpress API routines to

amend the problem with rows and quadratic terms.

p = xp.problem ()

N = 5

S = range (N)

x = [xp.var (vartype = xp.binary) for i in S]

Fair Isaac Corporation Conﬁdential and Proprietary Information 32

Examples of use

p.addVariable (x)

# vectors can be used whole or addressed with their index

c0 = xp.Sum (x) <= 10

cc = [x[i]/1.1 <= x[i+1]*2 for i in range (N-1)]

p.addConstraint (c0, cc)

p.setObjective (3 - x[0])

mysol = [0, 0, 1, 1, 1, 1.4]

# add a variable with its coefficients

p.addcols ([4], [0,3], [c0,4,2], [-3, 2.4, 1.4], [0], [2], [’Y’], [’B’])

p.write ("problem1", "lp")

# load a MIP solution

p.loadmipsol ([0,0,1,1,1,1.4])

We now add a quadratic term x

− 2x

+ x

to the second constraint. Note that the -2 coefﬁcient

for an off-diagonal element must be passed divided by two.

The same effect would be obtained with p.addqmatrix (cc[0], [x[0],x[3],x[3]],

[x[0],x[0],x[3]], [1,-1,1])

As constraint vector cc was added after c0, it is the latter which has index 0 in the problem, while

cc[0] has index 1.

We then add the seventh and eighth constraints:

subject to: x

+ 2 x

+ 3x

≥ 4

+ 5x

+ 6x

+ 7 x

+ 8 x

+ y ≤ 4.4

Note the new column named ’Y’ is added with its index 5 (variables’ indices begin at 0). The same

would happen if 5 were substituted by Y.

p.addqmatrix (1, [x[0],x[3],x[3]], [x[0],x[0],x[3]], [1,-1,1])

p.addrows (qrtype = [’G’, ’L’],

rhs = [4, 4.4],

mstart = [0, 3, 9],

mclind = [x[0],x[1],x[2], x[0],x[1],x[2],x[3],x[4], 5],

dmatval = [1,2,3,4,5,6,7,8,-3],

names = [’newcon1’, ’newcon2’])

p.solve ()

p.write ("amended", "lp")

slacks = []

p.calcslacks (solution = mysol, calculatedslacks = slacks)

print ("slacks:", slacks)

The code below add ﬁve columns, then solves the problem and prints the solution, if one has

been found.

p.addcols ([4], [0,3], [c0,4,2], [-3, -2, 1], [0], [2], [’p1’], [’I’])

p.addcols ([4], [0,3], [c0,4,2], [-3, 2.4, 1.4], [0], [10], [’p2’], [’C’])

p.addcols ([4], [0,3], [c0,4,2], [-3, 2, 1], [0], [1], [’p3’], [’S’])

p.addcols ([4], [0,3], [c0,4,2], [-3, 2.4, 4], [0], [2], [’p4’], [’P’])

p.addcols ([4], [0,3], [c0,4,2], [-3, 2, 1], [0], [2], [’p5’], [’R’])

Fair Isaac Corporation Conﬁdential and Proprietary Information 33

Examples of use

p.solve ()

try:

print ("new solution:", p.getSolution ())

except:

print ("could not get solution, perhaps problem is infeasible")

Note that the single command below has the same effect as the four addcols calls above, and is

to be preferred when adding a large number of columns for reasons of efﬁciency.

p.addcols ([4,4,4,4,4],

[0,3,6,9,12,15],

[c0,4,2,c0,4,2,c0,4,2,c0,4,2,c0,4,2],

[3, -2, 1, -3, 2.4, 1.4, 3, 2, 1, -3, 2.4, 4, 3, 2, 1],

[0,0,0,0,0],

[2,10,1,2,2],

[’p1’,’p2’,’p3’,’p4’,’p5’],

[’I’,’C’,’S’,’P’,’R’])

6.4.4 Combining modeling and API functions

This is an example where a problem is loaded from a ﬁle, solved, then modiﬁed by adding a

Global Upper Bound (GUB) constraint. Note that we do not know the structure of the problem

when reading it, yet we can simply extract the list of variables and use them to add a constraint.

p = xpress.problem ()

p.read ("example.lp")

p.solve ()

print ("solution of the original problem: ", p.getVariable(), "==>", p.getSolution())

After solving the problem, we obtain its variables through getVariable and add a constraints so

that their sum cannot be more than 1.1.

x = p.getVariable ()

p.addConstraint (xpress.Sum (x) <= 1.1)

p.solve()

print ("New solution: ", p.getSolution ())

6.4.5 A simple Traveling Salesman Problem (TSP) solver

A classical example of use of callbacks is the development of a simple solver for the well-known

TSP problem. The aim here is not to create an efﬁcient solver (there are far better

implementations), but rather a simple solver where the user only needs to specify two callbacks:

one for checking whether a given solution forms a Hamiltonian tour and one for separating a

subtour elimination constraint from the current node solution.

After a successful solve (or an interrupted one with a feasible solution), the best Hamiltonian tour

is displayed. Note that this section omits unnecessary details (checks of return values, exceptions,

etc.) of the actual code, which can be found in the Examples/ directory.

import networkx as nx

import xpress as xp

import re, math, sys

from matplotlib import pyplot as plt

import urllib.request as ul

filename = ’dj38.tsp’

Fair Isaac Corporation Conﬁdential and Proprietary Information 34

Examples of use

ul.urlretrieve (’http://www.math.uwaterloo.ca/tsp/world/’ + filename, filename)

instance = open (filename, ’r’)

coord_section = False

points = {}

G = nx.Graph ()

We have downloaded an instance of the TSP and now it must be read and interpreted as it does

not have a format that we know. We save in cx and cy the coordinates of all nodes in the graph,

which is assumed to be complete, i.e., all nodes are connected to one another.

for line in instance.readlines ():

if re.match (’NODE_COORD_SECTION.*’, line):

coord_section = True

continue

elif re.match (’EOF.*’, line):

break

if coord_section:

coord = line.split (’ ’)

index = int (coord [0])

cx = float (coord [1])

cy = float (coord [2])

points [index] = (cx, cy)

G.add_node (index, pos = (cx, cy))

The next step is to deﬁne a callback function for checking if the solution forms a Hamiltonian

tour, i.e., if it connects all nodes of the graph. The callback will be passed with the method

addcbpreintsol, therefore it needs to return a tuple of two values: the ﬁrst value is True if the

solution should be rejected, and the second is the new cutoff in case it has to be changed. This is

not the case here, so None can be safely returned.

After obtaining the integer solution to be checked, the function scans the graph from node 1 to

see if the solutions at one form a tour.

def check_tour (prob, G, isheuristic, cutoff):

s = []

prob.getlpsol (s, None, None, None)

orignode = 1

nextnode = 1

card = 0

while nextnode != orignode or card == 0:

FS = [j for j in V if j != nextnode

and s[prob.getIndex (x[nextnode,j])] == 1] # forward star

card += 1

if len (FS) < 1:

return (True, None) # reject solution if we can’t close the loop

nextnode = FS [0]

# If there are n arcs in the loop, the solution is feasible

return (card < n, None) # accept the cutoff: return second element as None

The second callback to be deﬁned is a separator for subtour elimination constraints. It must

return a nonzero value if the node is deemed infeasible by the function, zero otherwise. The

function addcuts is used to insert a subtour elimination constraint.

Fair Isaac Corporation Conﬁdential and Proprietary Information 35

Examples of use

The function works as follows: Starting from node 1, gather all connected nodes of a loop in

connset. If this set contains all nodes, then the solution is valid if integer, otherwise the function

adds a subtour elimination constraint in the form of a clique constraint with all arcs (i, j) for all i, j

in connset.

def eliminate_subtour (prob, G):

s = [] # initialize s to an empty string to provide it as an output parameter

prob.getlpsol (s, None, None, None)

orignode = 1

nextnode = 1

connset = []

while nextnode != orignode or len (connset) == 0:

connset.append (nextnode)

FS = [j for j in V if j != nextnode

and s [prob.getIndex (x [nextnode, j])] == 1] # forward star

if len (FS) < 1:

return 0

nextnode = FS [0]

if len (connset) < n:

# Add a subtour elimination using the nodes in connset (or, if

# card (connset) > n/2, its complement)

if len (connset) <= n/2:

columns = [x[i,j] for i in connset for j in connset

if i != j]

nArcs = len (connset)

else:

columns = [x[i,j] for i in V for j in V

if not i in connset and not j in connset and i != j]

nArcs = n - len (connset)

nTerms = len (columns)

prob.addcuts ([1], [’L’], [nArcs - 1], [0, nTerms], columns, [1] * nTerms)

return 0

We now formulate the problem with the degree constraints on each node and the objective

function (the cost of each arc (i, j) is assumed to be the Euclidean distance between i and j).

n = len (points) # number of nodes

V = range (1, n+1) # set of nodes

A = [(i,j) for i in V for j in V if i != j] # set of arcs (i.e. all pairs)

x = {(i,j): xp.var (name = ’x_{0}_{1}’.format (i,j), vartype = xp.binary) for (i,j) in A}

conservation_in = [xp.Sum (x[i,j] for j in V if j != i) == 1 for i in V]

conservation_out = [xp.Sum (x[j,i] for j in V if j != i) == 1 for i in V]

p = xp.problem ()

p.addVariable (x)

p.addConstraint (conservation_in, conservation_out)

xind = {(i,j): p.getIndex (x[i,j]) for (i,j) in x.keys ()}

Fair Isaac Corporation Conﬁdential and Proprietary Information 36

Examples of use

# Objective function: total distance travelled

p.setObjective (xp.Sum (math.sqrt ((points[i][0] - points[j][0])**2 +

(points[i][1] - points[j][1])**2) *

x[i,j]

for (i,j) in A))

p.controls.maxtime = -2000 # negative for "stop even if no solution is found"

p.addcboptnode (eliminate_subtour, G, 1)

p.addcbpreintsol (check_tour, G, 1)

We now solve the problem, and if a solution is found it is displayed using the Python library

matplotlib.

p.solve ()

sol = p.getSolution ()

# Read solution and store it in the graph

for (i,j) in A:

if sol [p.getIndex (x[i,j])] > 0.5:

G.add_edge (i,j)

# Display best tour found

pos = nx.get_node_attributes (G, ’pos’)

nx.draw (G, points) # create a graph with the tour

plt.show () # display it interactively

Fair Isaac Corporation Conﬁdential and Proprietary Information 37

CHAPTER 7

Reference Manual

7.1 Using this chapter

This chapter provides a list of functions available through the Xpress Python interface. For each

function, the synopsis and an example are given.

In keeping with the Xpress Optimizer’s C API, the name and order of the parameters used in

these functions has been retained. However, in order to make optimal use of the greater

ﬂexibility provided by Python, the argument lists and the return value of some functions has been

modiﬁed so as to obtain a more compact notation.

For example, for functions with a list as an argument, the number of elements of the list is not

part of the arguments. Compare the call to the C function XPRSaddrows, where the parameters

newrow and newnz must be passed, to its Python counterpart:

rhs, NULL, mstart, indices, values);

(Python) p.addrows (type, rhs, None, mstart, indices, values)

In the Python version, the prob pointer is not provided as obviously addrows is a method of the

problem class. The C variables n and nnz, which are assigned to arguments newrow and newnz,

respectively, of the call to XPRSaddrows, are not necessary in the Python call as the length of rhs,

mstart, etc. is inferred from the passed lists. If the lengths of all lists passed as arguments are not

consistent with one another, an error will be returned.

Because Python lists (or tuples, generators, iterators, sequences) can be used as parameters of all

functions in this manual, their size does not need to be passed explicitly as it is detected from the

parameter itself. The interface will check the consistency and the content if the vector is referred

to the variables or constraints, and will return an error in case of a mismatch.

Another difference between the Python methods and their C API counterpart is that some output

arguments are no longer passed (by reference) as arguments to the Python functions but rather

are (part of) the value returned by the function. Where multiple scalar output parameters are

returned by the C API function, some Python functions return a tuple containing all such output

values.

The non-scalar parameters can instead be speciﬁed as Python lists, NumPy arrays, sequences, or

generators when applicable. The output non-scalar parameters are stored as Python lists.

Optional parameters can be speciﬁed as None or skipped, provided the subsequent arguments are

explicitly declared with their parameter name as Python allows:

p.addrows (qrtype = type, rhs = rhs, mstart = mstart,

mclind = indices, dmatval = values)

Fair Isaac Corporation Conﬁdential and Proprietary Information 38

Reference Manual

Because the Python interface relies on the Xpress Optimizer low-level interface, it is advisable to

complement the knowledge in this reference manual with that of the Xpress Optimizer reference

manual.

Format of the reference

The descriptions in the following pages report, for each function:

 Name;

 A short description of its purpose;

 Its synopsis, i.e., how it must be called. If it returns a value, then it will be presented as an

assignment Python command, otherwise it will be just shown as a call without a returned

value; also, if it is a module function rather than a problem-speciﬁc function, it will be

preﬁxed by xpress;

 A description of its arguments and whether each argument is optional;

 Error values;

 Associated controls;

 A sample usage of the function;

 Further useful information about the function;

 Related functions, parameters.

Note that all arguments deﬁned in the following as "array" can be many other Python non-scalar

objects: lists, generators, and NumPy arrays are admissible as parameters, except when speciﬁed

(e.g. getControl). However, for simplicity we refer to non-scalar arguments as array.

Finally, some attributes and controls are referred to as uppercase words for clarity. For example,

ROWS indicates the attribute "rows" of a problem, hence it is equivalent to

problem.attributes.rows.

7.2 Global methods of the Xpress module

Below is a list of functions that are invoked from the Xpress module, i.e., they are not methods of

the problem or the branchobj class and can be invoked after the import command. The invocation

is therefore as in the example that follows:

import xpress as xp

print (xp.getlasterror ())

xpress.init xpress.free xpress.addcbmsghandler

xpress.getbanner xpress.getcheckedmode xpress.getdaysleft

xpress.getlasterror xpress.getlicerrmsg xpress.getversion

xpress.Sum xpress.Dot xpress.setcheckedmode

xpress.removecbmsghandler xpress.setdefaultcontrol xpress.setdefaults

Fair Isaac Corporation Conﬁdential and Proprietary Information 39

Reference Manual

7.3 Methods of the problem class

The tables below show all methods of the class problem of the Xpress Python interface, with the

exception of callbacks, which are listed separately. Their invocation is therefore to be preceded by

a problem object (the class preﬁx problem. is omitted in the table for compactness), as follows:

import xpress as xp

x = xp.var ()

p = xp.problem ()

p.setObjective (x + 3 * x**2 + 2)

addcols addConstraint addIndicator addmipsol

addqmatrix addrows addSOS addVariable

basisstability btran calcobjective calcreducedcosts

calcslacks calcsolinfo chgbounds chgcoef

chgcoltype chgglblimit chgmcoef chgmqobj

chgobj chgobjsense chgqobj chgqrowcoeff

chgrhs chgrhsrange chgrowtype copy

copycontrols delConstraint delqmatrix delSOS

delVariable dumpcontrols estimaterowdualranges fixglobals

ftran

getAttrib getbasis getcoef getcols

getcoltype getConstraint getControl getdirs

getDual getdualray getglobal getiisdata

getIndex getIndexFromName getindicators getinfeas

getlasterror getlb getlpsol getmessagestatus

getmipsol getmqobj getobj getObjVal

getpivotorder getpivots getpresolvebasis getpresolvemap

getpresolvesol getprimalray getProbStatus getProbStatusString

getqobj getqrowcoeff getqrowqmatrix getqrowqmatrixtriplets

getqrows getRCost getrhs getrhsrange

getrows getrowtype getscaledinfeas getSlack

getSolution getSOS getub getunbvec

getVariable hasdualray hasprimalray

Fair Isaac Corporation Conﬁdential and Proprietary Information 40

Reference Manual

iisall iisclear iisfirst

iisisolations iisnext iisstatus

iiswrite loadbasis loadbranchdirs

loaddelayedrows loaddirs loadlpsol

loadmipsol loadmodelcuts loadpresolvebasis

loadpresolvedirs loadproblem loadsecurevecs

lpoptimize mipoptimize name

objsa postsolve presolverow

read readbasis readbinsol

readdirs readslxsol refinemipsol

repairinfeas repairweightedinfeas repairweightedinfeasbounds

restore reset rhssa

save scale setControl

setdefaults setindicators setlogfile

setmessagestatus setObjective setprobname

solve strongbranch write

writebasis writebinsol writedirs

writeprtsol writeslxsol writesol

The following table contains the problem functions to be called for nonlinear problems.

addcoefs adddfs addtolsets

addvars cascade cascadeorder

chgcascadenlimit chgccoef chgnlcoef

chgdeltatype chgdf chgrowstatus

chgrowwt chgtolset chgvar

construct delcoefs deltolsets

delvars evaluatecoef evaluateformula

filesol fixpenalties getccoef

getcoefformula getcoefs getcolinfo

getdf getdtime getmessagetype

getrowinfo getrowstatus getrowwt

getslpsol gettolset getvar

globalsol loadcoefs loaddfs

loadtolsets loadvars msaddcustompreset

msaddjob msaddpreset msclear

parsecformula parseformula preparseformula

presolve printmemory printevalinfo

printmsg reinitialize scaling

setcurrentiv setuniqueprefix tokencount

unconstruct updatelinearization validformula

validate validatekkt validaterow

validatevector

Fair Isaac Corporation Conﬁdential and Proprietary Information 41

Reference Manual

7.4 Methods for branching objects

The following pages present the methods of the branchobj class, i.e., the methods used when

creating and manipulating branching objects. Their invocation can be as follows:

import xpress as xp

b = xp.branchobj ()

b.addbranches (3)

branchobj.addbounds branchobj.addbranches branchobj.addcuts

branchobj.addrows branchobj.getbounds branchobj.getbranches

branchobj.getid branchobj.getlasterror branchobj.getrows

branchobj.setpreferredbranch branchobj.setpriority branchobj.store

branchobj.validate

7.5 Methods for adding/removing callbacks of a problem object

The following pages present methods that can be called from a problem before optimization has

started, to add or remove callbacks. All these methods are part of the problem class and have to

be instantiated from a problem object.

addcbbariteration removecbbariteration

addcbbarlog removecbbarlog

addcbchgbranchobject removecbchgbranchobject

addcbcutlog removecbcutlog

addcbdestroymt removecbdestroymt

addcbgapnotify removecbgapnotify

addcbgloballog removecbgloballog

addcbinfnode removecbinfnode

addcbintsol removecbintsol

addcblplog removecblplog

addcbmessage removecbmessage

addcbmipthread removecbmipthread

addcbnewnode removecbnewnode

addcbnodecutoff removecbnodecutoff

addcboptnode removecboptnode

addcbpreintsol removecbpreintsol

addcbprenode removecbprenode

addcbusersolnotify removecbusersolnotify

7.6 Methods to be used within a callback of a problem object

The following methods can be called from within a callback function that has been passed in one

Fair Isaac Corporation Conﬁdential and Proprietary Information 42

Reference Manual

of the problem.addcb* methods. Calling these functions outside of a callback may result in an

error and trigger termination of the optimization process. We provide two tables: one is for the

Optimizer and another for the nonlinear solvers.

copycallbacks delcpcuts delcuts

getcpcutlist getcpcuts getcutlist

getcutmap getcutslack interrupt

loadcuts setbranchbounds setbranchcuts

storebounds storecuts strongbranchcb

addcuts

setcbcascadeend setcbcascadestart setcbcascadevar

setcbcascadevarfail setcbcoefevalerror setcbconstruct

setcbdestroy setcbdrcol setcbformula

setcbiterend setcbiterstart setcbitervar

setcbmsjobend setcbmsjobstart setcbmswinner

setcbslpend setcbslpnode setcbslpstart

Fair Isaac Corporation Conﬁdential and Proprietary Information 43

Reference Manual

xpress.free

Purpose

Releases the Xpress environment, thus freeing up one license. The subsequent creation of a

problem automatically triggers a call to xpress.init.

Note that it is unnecessary to call this function upon exiting a block that uses the Xpress module,

or when the optimizer is no longer used, as Python will release the Xpress environment when

freeing the Xpress module. This function might be useful when a license is needed by another

user or program, and one wishes to release the license.

Synopsis

xpress.free ()

Example

The following example shows how to call xpress.free and a possible use:

x = xp.var ()

y = xp.var ()

p = xp.problem () # This would imply a call to xp.init()

p.addVariable (x, y)

p.addConstraint (x+y <= 1)

p.setObjective (x+2*y, sense=xp.maximize)

p.solve ()

xp.free () # from this point on, the license

# can be claimed by other users

Note that xpress.init is only useful when the user wants to claim a license that might be used by

another program or user.

Further information

Similar to a call to XPRSfree() of the C API, calling xpress.free cleans the Xpress environment.

Any problem created prior to a call to xpress.free is no longer available, and referring to it may

lead to errors. For instance, the following code results in an aborted run:

import xpress p = xpress.problem () xpress.free() xpress.init()

p.solve ()

Related topics

xpress.init

Fair Isaac Corporation Conﬁdential and Proprietary Information 44

Reference Manual

xpress.getbanner

Purpose

Returns the banner and copyright message.

Synopsis

i = xpress.getbanner ()

Example

print (xpress.getbanner ())

Fair Isaac Corporation Conﬁdential and Proprietary Information 45

Reference Manual

xpress.getcheckedmode

Purpose

Returns whether checking & validation of all Optimizer function calls is enabled for the current

process. Checking & validation is enabled by default but can be disabled by

xpress.setcheckedmode.

Synopsis

i = xpress.getcheckedmode ()

Related topics

xpress.setcheckedmode.

Fair Isaac Corporation Conﬁdential and Proprietary Information 46

Reference Manual

xpress.getdaysleft

Purpose

Returns the number of days left until an evaluation license expires.

Synopsis

d = xpress.getdaysleft ()

Example

The following calls getdaysleft to print information about the license:

try:

ndays = xpress.getdaysleft ()

except RuntimeError:

print ("Not an evaluation license")

else

print ("Evaluation license expires in {0} days".format (ndays))

Further information

This function can only be used with evaluation licenses, and if called when a normal license is in

use returns an error. The expiry information for evaluation licenses is also included in the

Optimizer banner message.

Fair Isaac Corporation Conﬁdential and Proprietary Information 47

Reference Manual

xpress.getlasterror

Purpose

Returns the last error encountered during a call to the Xpress global environment.

Synopsis

(i,s) = xpress.getlasterror ()

Arguments

i Error code

s Error message relating to the global environment will be returned.

Example

import xpress as xp

# last error referring to the global environment

print (xp.getlasterror ())

Fair Isaac Corporation Conﬁdential and Proprietary Information 48

Reference Manual

xpress.getlicerrmsg

Purpose

Returns the error message string describing the last licensing error, if any occurred.

Synopsis

m = xpress.getlicerrmsg ()

Example

The following calls getlicerrmsg to ﬁnd out why the import of the Xpress Python module failed:

try:

import xpress

except RuntimeError:

print (xpress.getlicerrmsg ())

else:

print ("all good")

Fair Isaac Corporation Conﬁdential and Proprietary Information 49

Reference Manual

xpress.getversion

Purpose

Returns the full Optimizer version number in the form 15.10.03, where 15 is the major release, 10

is the minor release, and 03 is the build number.

Synopsis

v = xpress.getversion ()

Example

print ("Using Xpress Optimizer version", xpress.getversion ())

Fair Isaac Corporation Conﬁdential and Proprietary Information 50

Reference Manual

xpress.init

Purpose

Initializes the Xpress environment prior to creating or reading a problem.

Note that it is not necessary to call this function after importing the Xpress module and before

creating or solving a problem, as Python will claim a license automatically. This function might be

useful when the user wants to reserve a license and prevent that it is claimed by user or program.

Synopsis

xpress.init ()

Example

The following example shows how to call xpress.init and why it could be useful:

xp.init () # reserves the license before creating variables

x = xp.var ()

y = xp.var ()

p = xp.problem () # This would imply a call to xp.init()

p.addVariable (x, y)

p.addConstraint (x+y <= 1)

p.setObjective (x+2*y, sense=xp.maximize)

p.solve ()

Note that the call to xpress.init is not necessary and should only be made when the user wants

to claim a license that might be used by another program or user before the call to

xpress.problem.

Related topics

xpress.free

Fair Isaac Corporation Conﬁdential and Proprietary Information 51

Reference Manual

xpress.setcheckedmode

Purpose

Disable/enable some of the checking & validation of function calls & function call parameters for

calls to the Xpress Optimizer API. This checking is relatively lightweight but disabling it can

improve performance in cases where non-intensive Xpress Optimizer functions are called

repeatedly in a short space of time.

Please note: after disabling function call checking & validation, invalid usage of Xpress Optimizer

functions may not be detected and may cause the Xpress Optimizer process to behave

unexpectedly or crash. It is not recommended to disable function call checking & validation

during application development.

Synopsis

xpress.setcheckedmode (checked_mode)

Argument

checked_mode Pass as 0 to disable much of the validation for all Xpress function calls from the

current process. Pass 1 to re-enable validation. By default, validation is enabled.

Related topics

xpress.getcheckedmode.

Fair Isaac Corporation Conﬁdential and Proprietary Information 52

Reference Manual

xpress.setdefaults

Purpose

Sets the module’s controls to their default values. This affects all problems created after calling

setdefaults, not before.

Synopsis

xpress.setdefaults ()

Example

The following creates two problems, one before and one after calling setdefaults():

xpress.controls.presolve = 0

p1 = xpress.problem()

xpress.setdefaults()

p2 = xpress.problem ()

print (’I bet p1.controls.presolve is 0: ’, p1.controls.presolve)

print (’I bet p2.controls.presolve is its default:’, p2.controls.presolve)

Related topics

xpress.setdefaultcontrol, problem.setdefaults, problem.setdefaultcontrol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 53

Reference Manual

xpress.setdefaultcontrol

Purpose

Sets one of the module’s controls to its default values. This affects all problems created after

calling setdefaults, not before.

Synopsis

xpress.setdefaultcontrol (control)

Argument

control Name of the control to be set to default.

Example

The following creates two problems, one before and one after calling

setdefaultcontrol(xpress.presolve):

xpress.controls.presolve = 0

p1 = xpress.problem ()

xpress.setdefaultcontrol (’presolve’)

p2 = xpress.problem ()

print (’I bet p1.controls.presolve is 0: ’, p1.controls.presolve)

print (’I bet p2.controls.presolve is its default:’, p2.controls.presolve)

Related topics

xpress.setdefaults, problem.setdefaults, problem.setdefaultcontrol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 54

Reference Manual

xpress.Sum

Purpose

Alternative sum operator for an arbitrary number of objects created by a Python list, tuple,

generator, NumPy array, dictionary, etc.

Synopsis

a = xpress.Sum (t1, t2, ...)

Example

The following are allowed uses of the Sum operator:

N = 20

S = range (S)

x = [xpress.var () for i in S]

y = [xpress.var (vartype = xpress.binary) for i in S]

p = xpress.problem ()

p.addVariable (x, y)

p.setObjective (x[0] + xpress.Sum (x[i]**2 for i in S))

p.addConstraint (xpress.Sum (x,y) <= 100)

p.addConstraint (xpress.Sum (x[:i]) + xpress.Sum (y[:i])

<= log (10 + i) for i in S)

Further information

The Sum operator is functionally equivalent to Python’s native sum operator. However, it is

strongly advised to use the Xpress’ Sum operator when constructing large expressions involving

variables, as doing otherwise might slow down the execution signiﬁcantly.

Fair Isaac Corporation Conﬁdential and Proprietary Information 55

Reference Manual

xpress.Dot

Purpose

Alternative dot-product operator for an arbitrary number of NumPy single- or multi-dimensional

arrays. Following the convention for dot-product, the result of Dot for a list of k objects

, T

, . . . , T

of d

, d

, . . . , d

dimensions is an object of d

+ d

+. . . +d

− 2(k − 1) dimensions. For

each i-th factor in [1,2,...,k − 1], the arity of the last dimension of T

must match the arity of the

penultimate dimension of T

i+1

(or its arity if T

i+1

is single-dimensional, i.e., a vector).

Synopsis

a = xpress.Dot (t1, t2, ..., out)

Argument

out (optional) NumPy array of the correct dimension and arity where the result is stored. If

not provided, the dot product is returned.

Example

The following code shows some possible uses of the Dot operator:

import numpy as np

import xpress as xp

N = 10

M = 20

S = range (N)

x = np.array ([xp.var () for i in S])

x0 = np.random.random (N) # creates an N-vector of random numbers

p = xp.problem ()

# objective function is the squared Euclidean distance of the

# variable vector x from a fixed point x0

p.setObjective (xp.Dot ((x-x0), (x-x0)))

A = np.random.random (M * N).reshape (M, N)

b = np.random.random (M)

# constraint Ax = b, random MxN matrix A and M-vector b

p.addConstraint (xp.Dot (A, x) == b)

# Create a single quadratic constraint with

# a positive semidefinite matrix Q + N^3 * I

Q = np.random.random (N,N)

p.addConstraint (xp.Dot (x, Q + N**3 * np.eye (N), x) <= 1)

# Create four quadratic constraints using an order-three

# tensor, i.e., a three-dimensional array.

k = 4

T = np.random.random (k,N,N)

q = np.random.random (k)

p.addConstraint (xp.Dot (x, T, x) <= q)

Fair Isaac Corporation Conﬁdential and Proprietary Information 56

Reference Manual

Further information

From an operational standpoint, the dot product of k multi-dimensional arrays is the result of

k − 1 dot products of two factors each, and proceeds as in the following Python code:

result = T[0]

for i in range (1,k):

result = xpress.Dot (result, T[i])

The dot product of two multi-dimensional array T

and T

of dimensions d

and d

and of arities

, n

, . . . , n

) and (m

, m

, . . . , m

), respectively, is a multi-dimensional array of dimension

+ d

− 2, whose arity vector is (n

, n

, . . . , n

−1

, m

, . . . , m

−2

, m

) and whose generic

element is

,...,i

−1

,...,j

−2

1≤h≤n

,...,i

−1

· t

,...,j

−2

,h,j

It is assumed here that n

= m

−1

. Two simple cases may help understand the behavior of the

operator: for two single-dimensional arrays v

and v

of size n, the result is the inner product

1≤h≤n

· v

For two matrices A and B of sizes m × n and n × p respectively, the result is the m × p matrix C

whose generic element is

1≤h≤n

· B

The Dot operator is functionally equivalent to Python’s dot operator from the NumPy package.

However, the Xpress Dot operator is the only one that can work on variables and expressions

containing variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 57

Reference Manual

xpress.Prod

Purpose

Returns the product of a sequence of one or more expressions.

Synopsis

a = xpress.Prod (t1, t2, ...)

Example

The following are allowed uses of the Prod operator:

n=10

x = [xp.var() for i in range (n)]

prod = xp.Prod(x)

polynomial = xp.Sum (i * xp.Prod (x[i:i+4]) for i in range (n-4))

Further information

While n-ary product operators may exist in Python and/or NumPy, it is advisable to use

xpress.Prod when creating products of many expressions as it is the most efﬁcient alternative.

Fair Isaac Corporation Conﬁdential and Proprietary Information 58

Reference Manual

xpress.exp

Purpose

Returns the exponential of a given expression.

Synopsis

a = xpress.exp (t)

Argument

t Exponent.

Further information

Using Python’s math library operator math.exp is only advisable when the argument is not an

expression that depends on variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 59

Reference Manual

xpress.log

Purpose

Returns the natural logarithm of a given expression.

Synopsis

a = xpress.log (t)

Argument

t Argument of the log function.

Further information

Using Python’s math library operator math.log is only advisable when the argument is not an

expression that depends on variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 60

Reference Manual

xpress.log10

Purpose

Returns the base-10 logarithm of a given expression.

Synopsis

a = xpress.log10 (t1)

Argument

t Argument.

Related topics

xpress.log.

Fair Isaac Corporation Conﬁdential and Proprietary Information 61

Reference Manual

xpress.sin

Purpose

Returns the sine of a given expression.

Synopsis

a = xpress.sin (t)

Argument

t Argument of the sine function.

Further information

Using Python’s math library operator math.sin is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.cos, xpress.tan, xpress.asin, xpress.acos, xpress.atan.

Fair Isaac Corporation Conﬁdential and Proprietary Information 62

Reference Manual

xpress.cos

Purpose

Returns the cosine of a given expression.

Synopsis

a = xpress.cos (t)

Argument

t Argument of the cosine function.

Further information

Using Python’s math library operator math.cos is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.sin, xpress.tan, xpress.asin, xpress.acos, xpress.atan.

Fair Isaac Corporation Conﬁdential and Proprietary Information 63

Reference Manual

xpress.tan

Purpose

Returns the tangent of a given expression.

Synopsis

a = xpress.tan (t)

Argument

t Argument of the tangent function.

Further information

Using Python’s math library operator math.tan is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.sin, xpress.cos, xpress.asin, xpress.acos, xpress.atan.

Fair Isaac Corporation Conﬁdential and Proprietary Information 64

Reference Manual

xpress.asin

Purpose

Returns the arcsine of a given expression.

Synopsis

a = xpress.asin (t)

Argument

t Argument of the arcsine function.

Further information

Using Python’s math library operator math.asin is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.sin, xpress.cos, xpress.tan, xpress.acos, xpress.atan.

Fair Isaac Corporation Conﬁdential and Proprietary Information 65

Reference Manual

xpress.acos

Purpose

Returns the arccosine of a given expression.

Synopsis

a = xpress.acos (t)

Argument

t Argument of the arccosine function.

Further information

Using Python’s math library operator math.acos is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.sin, xpress.cos, xpress.tan, xpress.asin, xpress.atan.

Fair Isaac Corporation Conﬁdential and Proprietary Information 66

Reference Manual

xpress.atan

Purpose

Returns the arctangent of a given expression.

Synopsis

a = xpress.atan (t)

Argument

t Argument of the arctangent function.

Further information

Using Python’s math library operator math.atan is only advisable when the argument is not an

expression that depends on variables.

Related topics

xpress.sin, xpress.cos, xpress.tan, xpress.asin, xpress.acos.

Fair Isaac Corporation Conﬁdential and Proprietary Information 67

Reference Manual

xpress.max

Purpose

Returns the maximum of one or more expressions.

Synopsis

a = xpress.max (t1, t2, ..., tn)

Argument

t1, t2... Arguments.

Further information

Using Python’s operator max is only advisable when the argument is not an expression that

depends on variables.

Related topics

xpress.min.

Fair Isaac Corporation Conﬁdential and Proprietary Information 68

Reference Manual

xpress.min

Purpose

Returns the minimum of one or more expressions.

Synopsis

a = xpress.min (t1, t2, ..., tn)

Argument

t1, t2... Arguments.

Further information

Using Python’s operator min is only advisable when the argument is not an expression that

depends on variables.

Related topics

xpress.max.

Fair Isaac Corporation Conﬁdential and Proprietary Information 69

Reference Manual

xpress.abs

Purpose

Returns the absolute value of a given expression

Synopsis

a = xpress.abs (t)

Argument

t Argument of the abs() function.

Further information

Using Python’s math library operator math.abs is only advisable when the argument is not an

expression that depends on variables. Python’s native abs operator is equivalent to xpress.abs

for arguments that are functions of variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 70

Reference Manual

xpress.sign

Purpose

Returns the sign of an expression: 1 if positive, -1 if negative, 0 if zero.

Synopsis

a = xpress.sign (t)

Argument

t Argument of the sign function.

Fair Isaac Corporation Conﬁdential and Proprietary Information 71

Reference Manual

xpress.erf

Purpose

Returns the error function with an expression as its argument.

Synopsis

a = xpress.erf (t)

Argument

t Argument of the function.

Further information

For reasons related to compilers and math libraries, on Windows machines this function can only

be used with Python 3.

Related topics

xpress.erfc.

Fair Isaac Corporation Conﬁdential and Proprietary Information 72

Reference Manual

xpress.erfc

Purpose

Returns the complementary error function with an expression as its argument.

Synopsis

a = xpress.erfc (t)

Argument

t Argument of the function.

Further information

For reasons related to compilers and math libraries, on Windows machines this function can only

be used with Python 3.

Related topics

xpress.erf.

Fair Isaac Corporation Conﬁdential and Proprietary Information 73

Reference Manual

xpress.sqrt

Purpose

Returns the square root of an expression.

Synopsis

a = xpress.sqrt (t)

Argument

t Radicand of the function.

Further information

Using Python’s math library operator math.sqrt is only advisable when the argument is not an

expression that depends on variables.

Fair Isaac Corporation Conﬁdential and Proprietary Information 74

Reference Manual

xpress.user

Purpose

Creates an expression that is computed by means of a user-speciﬁed function.

Synopsis

def f (a1, a2, ..., an): [...] a = xpress.user (f, t1, t2, ..., tn)

Arguments

f User function; must be a Python function with as many (possibly optional) arguments as

speciﬁed in the declaration.

t1,...,tn Arguments of the user function.

Example

The following code shows how to deﬁne user functions:

import math

def mynorm (v):

return math.sqrt (sum (v[i] for i in range (len (v)))

def weighted_sum (t1, t2, t3 = 0):

return 2*t1 + 3*t2 + 4*t3

x = [xp.var() for i in range (20)]

f1 = xp.user (mynorm, x)

f2 = xp.user (weighted_sum, x[0], x[1], x[2])

# doesn’t use optional arg

f3 = xp.user (weighted_sum, x[0], x[1])

Further information

User functions must return a Float, as the behaviour is otherwise undeﬁned.

Fair Isaac Corporation Conﬁdential and Proprietary Information 75

Reference Manual

xpress.addcbmsghandler

Purpose

Declares an output callback function in the global environment, called every time a line of

message text is output by any object in the library. This callback function will be called in addition

to any output callbacks already added by xpress.addcbmsghandler.

Synopsis

xpress.addcbmsghandler (f_msghandler, object, priority)

ret = f_msghandler (vObject, vUserContext, vSystemThreadId, sMsg, iMsgType,

iMsgNumber)

Arguments

f_msghandler The callback function which takes six arguments, vObject, vUserContext,

vSystemThreadId, sMsg, iMsgType and iMsgNumber. Use None to cancel a callback

function.

vObject The object sending the message.

vUserContext The user-deﬁned object passed to the callback function.

vSystemThreadId The system id of the thread sending the message cast to a void *.

sMsg A string containing the message, which may simply be a new line. When the

callback is called for the ﬁrst time sMsg will be empty.

iMsgType Indicates the type of output message:

1 information messages;

2 (not used);

3 warning messages;

4 error messages.

When the callback is called for the ﬁrst time iMsgType will be a negative value.

iMsgNumber The number associated with the message. If the message is an error or a warning

then you can look up the number in the section Optimizer Error and Warning

Messages for advice on what it means and how to resolve the associated issue.

object A user-deﬁned object to be passed to the callback function.

priority An integer that determines the order in which multiple message handler callbacks

will be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Further information

To send all messages to a log ﬁle the built in message handler logfilehandler can be used. This

can be done with:

xpress.addcbmsghandler (logfilehandler,

’log.txt’, 0)

Related topics

xpress.removecbmsghandler.

Fair Isaac Corporation Conﬁdential and Proprietary Information 76

Reference Manual

xpress.removecbmsghandler

Purpose

Removes a message callback function previously added by xpress.addcbmsghandler. The speciﬁed

callback function will no longer be called after it has been removed.

Synopsis

xpress.removecbmsghandler (f_msghandler, object)

Arguments

f_msghandler The callback function to remove. If None then all message callback functions

added with the given user-deﬁned object value will be removed.

object The object value that the callback was added with. If None, then the object value

will not be checked and all message callbacks with the function pointer

f_msghandler will be removed.

Related topics

xpress.addcbmsghandler.

Fair Isaac Corporation Conﬁdential and Proprietary Information 77

Reference Manual

problem.addcbbariteration

Purpose

Declares a barrier iteration callback function, called after each iteration during the interior point

algorithm, with the ability to access the current barrier solution/slack/duals or reduced cost

values, and to ask barrier to stop. This callback function will be called in addition to any callbacks

already added by addcbbariteration.

Synopsis

problem.addcbbariteration (f_bariteration, object, priority)

barrier_action = f_bariteration (my_prob, my_object)

Arguments

f_bariteration The callback function itself. This takes two arguments, my_prob and my_object,

and returns an integer return value. This function is called at every barrier

iteration.

my_prob The problem passed to the callback function, fubi.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbbariteration.

barrier_action Deﬁnes a return value controlling barrier:

<0 continue with the next iteration;

=0 let barrier decide (use default stopping criteria)

1 barrier stops with status not deﬁned;

2 barrier stops with optimal status;

3 barrier stops with dual infeasible status;

4 barrier stops wih primal infeasible status;

object A user-deﬁned object to be passed to the callback function, f_bariteration.

priority An integer that determines the order in which callbacks of this type will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

This simple example demonstrates how the solution might be retrieved for each barrier iteration.

# Barrier iteration callback

def BarrierIterCallback (my_prob, my_object):

current_iteration = my_prob.attributes.bariter

PrimalObj = my_prob.attributes.barprimalobj

DualObj = my_prob.attributes.bardualobj

Gap = DualObj - PrimalObj

PrimalInf = my_prob.attributes.barprimalinf

DualInf = my_prob.attributes.bardualinf

ComplementaryGap = my_prob.attributes.barcgap

# decide if stop or continue

barrier_action = 0

if (current_iteration >= 50 or

Gap <= 0.1 * max (abs (PrimalObj), abs (DualObj))):

barrier_action = 2

return barrier_action

Fair Isaac Corporation Conﬁdential and Proprietary Information 78

Reference Manual

# To set callback:

xprob.addcbbariteration (BarrierIterCallback, myobj, 0)

Further information

1. Only the following functions are expected to be called from the callback: problem.getlpsol and

the attribute/control value retrieving and setting routines.

2. Please note that these values refer to the scaled and presolved problem used by barrier, and may

differ from the ones calculated from the postsolved solution returned by problem.getlpsol.

Related topics

problem.removecbbariteration.

Fair Isaac Corporation Conﬁdential and Proprietary Information 79

Reference Manual

problem.addcbbarlog

Purpose

Declares a barrier log callback function, called at each iteration during the interior point

algorithm. This callback function will be called in addition to any barrier log callbacks already

added by addcbbarlog.

Synopsis

problem.addcbbarlog (f_barlog, object, priority)

ret = f_barlog (my_prob, my_object)

Arguments

f_barlog The callback function itself. This takes two arguments, my_prob and my_object, and

has an integer return value. If the value returned by f_barlog is nonzero, the

solution process will be interrupted. This function is called at every barrier

iteration.

my_prob The problem passed to the callback function, f_barlog.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbbarlog.

object A user-deﬁned object to be passed to the callback function, f_barlog.

priority An integer that determines the order in which multiple barrier log callbacks will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

This simple example prints a line to the screen for each iteration of the algorithm.

prob.addcbbarlog (barLog, None, 0)

prob.lpoptimize (’b’)

The callback function might resemble:

def barLog (prob, object):

print (’Next barrier iteration’)

Further information

If the callback function returns a nonzero value, the Optimizer run will be interrupted.

Related topics

problem.removecbbarlog, problem.addcbgloballog, problem.addcblplog, problem.addcbmessage.

Fair Isaac Corporation Conﬁdential and Proprietary Information 80

Reference Manual

problem.addcbchgbranchobject

Purpose

Declares a callback function that will be called every time the Optimizer has selected a global

entity for branching. Allows the user to inspect and override the Optimizer’s branching choice.

This callback function will be called in addition to any callbacks already added by

problem.addcbchgbranchobject.

Synopsis

problem.addcbchgbranchobject (f_chgbranchobject, object, priority)

newobject = f_chgbranchobject (my_prob, my_object, obranch)

Arguments

f_chgbranchobject The callback function, which takes three arguments: my_prob, my_object,

and obranch. This function is called every time the Optimizer has selected a

candidate entity for branching.

my_prob The problem passed to the callback function, f_chgbranchobject.

my_object The user deﬁned object passed as object when setting up the callback with

addcbchgbranchobject.

obranch The candidate branching object selected by the Optimizer.

newobject New branching object to replace the Optimizer’s selection. Can be None.

object A user-deﬁned object to be passed to the callback function, f_chgbranchobject.

priority An integer that determines the order in which multiple callbacks of this type will

be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Further information

1. The branching object given by the Optimizer provides a linear description of how the Optimizer

intends to branch on the selected candidate. This will often be one of standard global entities of

the current problem, but can also be e.g. a split disjunction or a structural branch, if those

features are turned on.

2. The functions branchobj.getbranches, branchobj.getbounds and branchobj.getrows can be used

to inspect the given branching object.

3. Refer to the branchobj class to learn how to create a new branching object to replace the

Optimizer’s selection. Note that the new branching object should be created with a priority value

no higher than the current object to guarantee it will be used for branching.

Related topics

problem.removecbchgbranchobject.

Fair Isaac Corporation Conﬁdential and Proprietary Information 81

Reference Manual

problem.addcbcutlog

Purpose

Declares a cut log callback function, called each time the cut log is printed. This callback function

will be called in addition to any callbacks already added by problem.addcbcutlog.

Synopsis

problem.addcbcutlog (f_cutlog, object, priority)

ret = f_cutlog (my_prob, my_object)

Arguments

f_cutlog The callback function which takes two arguments, my_prob and my_object, and has

an integer return value.

my_prob The problem passed to the callback function, f_cutlog.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbcutlog.

object A user-deﬁned object to be passed to the callback function, f_cutlog.

priority An integer that determines the order in which multiple cut log callbacks will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Further information

The callback f_cutlog should return a non-zero value to stop cutting on the current node.

Related topics

problem.removecbcutlog.

Fair Isaac Corporation Conﬁdential and Proprietary Information 82

Reference Manual

problem.addcbdestroymt

Purpose

Declares a callback function that is called every time a MIP thread is destroyed by the parallel MIP

code. This callback function will be called in addition to any callbacks already added by

addcbdestroymt.

Synopsis

problem.addcbdestroymt (f_destroymt, object, priority)

f_destroymt (my_prob, my_object)

Arguments

f_destroymt The callback function which takes two arguments, my_prob and my_object, and has

no return value.

my_prob The thread problem passed to the callback function.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbdestroymt.

object A user-deﬁned object to be passed to the callback function.

priority An integer that determines the order in which multiple callbacks of this type will

be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Further information

This callback is useful for freeing up any user data created in the MIP thread callback.

Related topics

problem.removecbdestroymt, problem.addcbmipthread.

Fair Isaac Corporation Conﬁdential and Proprietary Information 83

Reference Manual

problem.addcbgapnotify

Purpose

Declares a gap notiﬁcation callback, to be called when a MIP solve reaches a predeﬁned target,

set using the miprelgapnotify, mipabsgapnotify, mipabsgapnotifyobj, and/or

mipabsgapnotifybound controls.

Synopsis

problem.addcbgapnotify (f_gapnotify, object, priority)

(RelGapNotify, AbsGapNotify, AbsGapNotifyObj, AbsGapNotifyBound) = f_gapnotify

(my_prob, my_object)

Arguments

f_gapnotify The callback function.

object A user-deﬁned object that wil be passed into the callback f_gpanotify.

priority An integer that determines the order in which multiple gap notiﬁcation callbacks

will be invoked. The callback added with the higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

my_prob The current problem.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbgapnotify.

RelGapNotify The value the miprelgapnotify control will be set to after this callback. May be

modiﬁed within the callback in order to set a new notiﬁcation target.

AbsGapNotify The value the mipabsgapnotify control will be set to after this callback. May be

modiﬁed within the callback in order to set a new notiﬁcation target.

AbsGapNotifyObj The value the mipabsgapnotifyobj control will be set to after this callback.

May be modiﬁed within the callback in order to set a new notiﬁcation target.

AbsGapNotifyBound The value the mipabsgapnotifybound control will be set to after this callback.

May be modiﬁed within the callback in order to set a new notiﬁcation target.

object A user-deﬁned object to be passed to the callback function, f_gapnotify.

priority An integer that determines the order in which multiple estimate callbacks will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

The following example prints a message when the gap reaches 10% and 1%

def gapnotify (prob, object):

obj = prob.attributes.mipobjval

bound = prob.attributes.bestbound

relgap = abs ((obj - bound) / obj)

newRelGapNotifyTarget = -1

if relgap <= 0.1:

print (’Gap reached 10%’)

newRelGapNotifyTarget = 0.1

if relgap <= 0.01:

print (’Gap reached 1%’)

newRelGapNotifyTarget = -1 # Don’t call gapnotify again

Fair Isaac Corporation Conﬁdential and Proprietary Information 84

Reference Manual

# return a quadruple with new values, or

# None for those that should not be set

return (newRelGapNotifyTarget, None, None, None)

prob.controls.miprelgapnotify = 0.1

prob.addcbgapnotify (gapnotify, None, 0)

prob.mipoptimize (’’)

Further information

The target values that caused the callback to be triggered will automatically be reset to prevent

the same callback from being ﬁred again.

Related topics

MIPRELGAPNOTIFY, MIPABSGAPNOTIFY, MIPABSGAPNOTIFYOBJ, MIPABSGAPNOTIFYBOUND,

problem.removecbgapnotify.

Fair Isaac Corporation Conﬁdential and Proprietary Information 85

Reference Manual

problem.addcbgloballog

Purpose

Declares a global log callback function, called each time the global log is printed. This callback

function will be called in addition to any callbacks already added by addcbgloballog.

Synopsis

problem.addcbgloballog (f_globallog, object, priority)

ret = f_globallog (my_prob, my_object)

Arguments

f_globallog The callback function which takes two arguments, my_prob and my_object, and has

an integer return value. This function is called whenever the global log is printed

as determined by the MIPLOG control.

my_prob The problem passed to the callback function, f_globallog.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbgloballog.

object A user-deﬁned object to be passed to the callback function, f_globallog.

priority An integer that determines the order in which multiple global log callbacks will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

The following example prints at each node of the global search the node number and its depth:

prob.controls.miplog = 3

prob.addcbgloballog (globalLog, None, 0)

prob.mipoptimize (’’)

The callback function may resemble:

def globalLog (prob, object):

nodedepth = prob.attributes.nodedepth

node = prob.attributes.currentnode

print (’Node {0} with depth {1} has been processed’.format

(node, nodedepth))

return 0

Further information

If the callback function returns a nonzero value, the global search will be interrupted.

Related topics

problem.removecbgloballog, problem.addcbbarlog, problem.addcblplog, problem.addcbmessage.

Fair Isaac Corporation Conﬁdential and Proprietary Information 86

Reference Manual

problem.addcbinfnode

Purpose

Declares a user infeasible node callback function, called after the current node has been found to

be infeasible during the Branch and Bound search. This callback function will be called in

addition to any callbacks already added by addcbinfnode.

Synopsis

problem.addcbinfnode (f_infnode, object, priority)

f_infnode (my_prob, my_object)

Arguments

f_infnode The callback function which takes two arguments, my_prob and my_object, and has

no return value. This function is called after the current node has been found to be

infeasible.

my_prob The problem passed to the callback function, f_infnode.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbinfnode.

object A user-deﬁned object to be passed to the callback function, f_infnode.

priority An integer that determines the order in which multiple user infeasible node

callbacks will be invoked. The callback added with a higher priority will be called

before a callback with a lower priority. Set to 0 if not required.

Example

The following notiﬁes the user whenever an infeasible node is found during the global search:

prob.addcbinfnode (nodeInfeasible, None, 0)

prob.mipoptimize ("")

The callback function may resemble:

def nodeInfeasible (prob, object):

node = prob.attributes.currentnode

print ("Node {0} infeasible".format (node))

Related topics

problem.removecbinfnode, problem.addcboptnode, problem.addcbintsol,

problem.addcbnodecutoff.

Fair Isaac Corporation Conﬁdential and Proprietary Information 87

Reference Manual

problem.addcbintsol

Purpose

Declares a user integer solution callback function, called every time an integer solution is found

by heuristics or during the Branch and Bound search. This callback function will be called in

addition to any callbacks already added by addcbintsol.

Synopsis

problem.addcbintsol (f_intsol, object, priority)

f_intsol (my_prob, my_object)

Arguments

f_intsol The callback function which takes two arguments, my_prob and my_object, and has

no return value. This function is called if the current node is found to have an

integer feasible solution, i.e. every time an integer feasible solution is found.

my_prob The problem passed to the callback function, f_intsol.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbintsol.

object A user-deﬁned object to be passed to the callback function, f_intsol.

priority An integer that determines the order in which multiple integer solution callbacks

will be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Example

The following example prints integer solutions as they are discovered in the global search:

prob.addcbintsol (printsol, None, 0)

prob.mipoptimize ("")

The callback function might resemble:

def printsol (my_prob, object):

cols = my_prob.attributes.originalcols

objval = my_prob.attributes.lpobjval

x = []

my_prob.getlpsol (x, None, None, None)

print ("Integer solution found:", objval, "; values:")

print (x)

Further information

1. This callback is useful if the user wants to retrieve the integer solution when it is found.

2. To retrieve the integer solution, use either problem.getlpsol or problem.getpresolvesol.

problem.getmipsol always returns the last integer solution found and, if called from the intsol

callback, it will not necessarily return the solution that caused the invocation of the callback (for

example, it is possible that when solving with multiple MP threads, another thread ﬁnds a new

integer solution before the user calls problem.getmipsol).

3. This callback is called after a new integer solution was found by the Optimizer. Use a callback set

by problem.addcbpreintsol in order to be notiﬁed before a new integer solution is accepted by

the Optimizer, which allows for the new solution to be rejected.

Related topics

problem.removecbintsol, problem.addcbpreintsol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 88

Reference Manual

problem.addcblplog

Purpose

Declares a simplex log callback function which is called after every LPLOG iterations of the simplex

algorithm. This callback function will be called in addition to any callbacks already added by

addcblplog.

Synopsis

problem.addcblplog (f_lplog, object, priority)

ret = f_lplog (my_prob, my_object)

Arguments

f_lplog The callback function which takes two arguments, my_prob and my_object, and has

an integer return value. This function is called every LPLOG simplex iterations

including iteration 0 and the ﬁnal iteration.

my_prob The problem passed to the callback function, f_lplog.

my_object The user-deﬁned object passed as object when setting up the callback with

addcblplog.

object A user-deﬁned object to be passed to the callback function, f_lplog.

priority An integer that determines the order in which multiple lplog callbacks will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

The following code sets a callback function, lpLog, to be called every 10 iterations of the

optimization:

prob.controls.lplog = 10

prob.addcblplog (lpLog, None, 0)

prob.read ("problem", "")

prob.mipoptimize ("")

The callback function may resemble:

def lpLog (my_prob, object):

iter = my_prob.attributes.simplexiter

obj = my_prob.attributes.lpobjval

print ("At iteration {0} objval is {1}".format (iter, obj))

return 0

Further information

If the callback function returns a nonzero value, the solution process will be interrupted.

Related topics

problem.removecblplog, problem.addcbbarlog, problem.addcbgloballog, problem.addcbmessage.

Fair Isaac Corporation Conﬁdential and Proprietary Information 89

Reference Manual

problem.addcbmessage

Purpose

Declares an output callback function, called every time a text line relating to the given prob is

output by the Optimizer. This callback function will be called in addition to any callbacks already

added by addcbmessage.

Synopsis

problem.addcbmessage (f_message, object, priority)

f_message (my_prob, my_object, msg, msgtype)

Arguments

f_message The callback function which takes ﬁve arguments, my_prob, my_object, msg, len and

msgtype, and has no return value. Use a None value to cancel a callback function.

my_prob The problem passed to the callback function.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbmessage.

msg A null terminated character array (string) containing the message, which may

simply be a new line.

msgtype Indicates the type of output message:

1 information messages;

2 (not used)

3 warning messages;

4 error messages.

A negative value indicates that the Optimizer is about to ﬁnish and the buffers

should be ﬂushed at this time if the output is being redirected to a ﬁle.

object A user-deﬁned object to be passed to the callback function.

priority An integer that determines the order in which callbacks of this type will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Example

The following example simply sends all output to the screen (stdout):

prob.addcbmessage (Message, None, 0)

The callback function might resemble:

def Message (my_prob, object, msg, msgtype):

print (’{0}: {1}’.format (msgtype, msg))

Further information

1. Screen output is automatically created by the Optimizer Console only. To produce output when

using the Optimizer library, it is necessary to deﬁne this callback function and use it to print the

messages to the screen (stdout).

2. This function offers one method of handling the messages which describe any warnings and

errors that may occur during execution. Other methods are to check the return values of

functions and then get the error code using the ERRORCODE attribute, obtain the last error

message directly using problem.getlasterror, or send messages direct to a log ﬁle using

problem.setlogfile.

Related topics

problem.removecbmessage, problem.addcbbarlog, problem.addcbgloballog, problem.addcblplog,

problem.setlogfile.

Fair Isaac Corporation Conﬁdential and Proprietary Information 90

Reference Manual

problem.addcbmipthread

Purpose

Declares a MIP thread callback function, called every time a MIP worker problem is created by the

parallel MIP code. This callback function will be called in addition to any callbacks already added

by addcbmipthread.

Synopsis

problem.addcbmipthread (f_mipthread, object, priority)

f_mipthread (my_prob, my_object, thread_prob)

Arguments

f_mipthread The callback function which takes three arguments, my_prob, my_object and

thread_prob, and has no return value.

my_prob The problem passed to the callback function.

my_object The user-deﬁned object passed to the callback function.

thread_prob The problem for the MIP thread

object A user-deﬁned object to be passed to the callback function.

priority An integer that determines the order in which multiple callbacks of this type will

be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Example

The following example clears the message callback for each of the MIP threads:

prob.addcbmipthread (mipthread, None, 0)

def mipthread (my_prob, my_object, mipthread):

my_prob.removecbmessage (mipthread, None)

Further information

This function will be called when a new MIP worker problem is created. Each worker problem

receives a unique identiﬁer that can be obtained through the MIPTHREADID attribute. Worker

problems can be matched with different system threads at different points of a solve, so the

system thread that is responsible for executing the callback is not necessarily the same thread

used for all subsequent callbacks for the same worker problem. On the other hand, worker

problems are always assigned to a single thread at a time and the same nodes are always solved

on the same worker problem in repeated runs of a deterministic MIP solve. A worker problem

therefore acts as a virtual thread through the node solves.

Related topics

problem.removecbmipthread, problem.addcbdestroymt.

Fair Isaac Corporation Conﬁdential and Proprietary Information 91

Reference Manual

problem.addcbnewnode

Purpose

Declares a callback function that will be called every time a new node is created during the

branch and bound search. This callback function will be called in addition to any callbacks already

added by addcbnewnode.

Synopsis

problem.addcbnewnode (f_newnode, object, priority)

f_newnode (my_prob, my_object, parentnode, newnode, branch)

Arguments

f_newnode The callback function, which takes ﬁve arguments: myprob, my_object, parentnode,

newnode and branch. This function is called every time a new node is created

through branching.

my_prob The problem passed to the callback function, f_newnode.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbnewnode.

parentnode Unique identiﬁer for the parent of the new node.

newnode Unique identiﬁer assigned to the new node.

branch The sequence number of the new node amongst the child nodes of parentnode.

For regular branches on a global entity this will be either 0 or 1.

object A user-deﬁned object to be passed to the callback function.

priority An integer that determines the order in which callbacks of this type will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Further information

1. For regular branches on a global entity, branch will be either zero or one, depending on whether

the new node corresponds to branching the global entity up or down.

2. When branching on a branchobject, branch refers to the given branch index of the object.

Related topics

problem.removecbnewnode.

Fair Isaac Corporation Conﬁdential and Proprietary Information 92

Reference Manual

problem.addcbnodecutoff

Purpose

Declares a user node cutoff callback function, called every time a node is cut off as a result of an

improved integer solution being found during the branch and bound search. This callback

function will be called in addition to any callbacks already added by addcbnodecutoff.

Synopsis

problem.addcbnodecutoff (f_nodecutoff, object, priority)

f_nodecutoff (my_prob, my_object, node)

Arguments

f_nodecutoff The callback function, which takes three arguments, my_prob, my_object and node,

and has no return value. This function is called every time a node is cut off as the

result of an improved integer solution being found.

my_prob The problem passed to the callback function, f_nodecutoff.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbnodecutoff.

node The number of the node that is cut off.

object A user-deﬁned object to be passed to the callback function, f_nodecutoff.

priority An integer that determines the order in which multiple node-optimal callbacks will

be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Example

The following notiﬁes the user whenever a node is cutoff during the global search:

prob.addcbnodecutoff (Cutoff, None, 0)

mipoptimize (prob, "")

The callback function might resemble:

def Cutoff (prob, object, node):

print ("Node {0} cutoff".format (node))

Further information

This function allows the user to keep track of the eligible nodes. Note that the LP solution will

not be available from this callback.

Related topics

problem.removecbnodecutoff, problem.addcboptnode, problem.addcbinfnode,

problem.addcbintsol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 93

Reference Manual

problem.addcboptnode

Purpose

Declares an optimal node callback function, called during the branch and bound search, after the

LP relaxation has been solved for the current node, and after any internal cuts and heuristics have

been applied, but before the Optimizer checks if the current node should be branched. This

callback function will be called in addition to any callbacks already added by addcboptnode.

Synopsis

problem.addcboptnode (f_optnode, object, priority)

feas = f_optnode (my_prob, my_object)

Arguments

f_optnode The callback function which takes three arguments, my_prob, my_object and feas,

and has no return value.

my_prob The problem passed to the callback function, f_optnode.

my_object The user-deﬁned object passed as object when setting up the callback with

addcboptnode.

feas The feasibility status. If set to a nonzero value by the user, the current node will be

declared infeasible.

object A user-deﬁned object to be passed to the callback function, f_optnode.

priority An integer that determines the order in which multiple node-optimal callbacks will

be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Example

The following prints the optimal objective value of the node LP relaxations:

prob.addcboptnode (nodeOptimal, None, 0)

prob.mipoptimize ("")

The callback function might resemble:

def nodeOptimal (prob, object, feas):

node = prob.attributes.currentnode

print ("NodeOptimal: node number", node)

objval = prob.attributes.lpobjval

print ("Objective function value =", objval)

Related topics

problem.removecboptnode, problem.addcbinfnode, problem.addcbintsol,

problem.addcbnodecutoff, CALLBACKCOUNT_OPTNODE.

Fair Isaac Corporation Conﬁdential and Proprietary Information 94

Reference Manual

problem.addcbpreintsol

Purpose

Declares a user integer solution callback function, called when an integer solution is found by

heuristics or during the branch and bound search, but before it is accepted by the Optimizer. This

callback function will be called in addition to any integer solution callbacks already added by

addcbpreintsol.

Synopsis

problem.addcbpreintsol (f_preintsol, object, priority)

(ifreject, newcutoff) = f_preintsol (my_prob, my_object, isheuristic, cutoff)

Arguments

f_preintsol The callback function which takes ﬁve arguments, my_prob, my_object,

isheuristic, ifreject and cutoff, and has no return value. This function is called

when an integer solution is found, but before the solution is accepted by the

Optimizer, allowing the user to reject the solution.

my_prob The problem passed to the callback function, f_preintsol.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbpreintsol.

isheuristic Set to 1 if the solution was found using a heuristic. Otherwise, it will be the global

feasible solution to the current node of the global search.

ifreject Set this to 1 if the solution should be rejected.

cutoff The current cutoff value.

newcutoff The new cutoff value, to be used by the Optimizer if the solution is accepted. The

returned newcutoff value will not be updated if the solution is rejected.

object A user-deﬁned object to be passed to the callback function, f_preintsol.

priority An integer that determines the order in which callbacks of this type will be

invoked. The callback added with a higher priority will be called before a callback

with a lower priority. Set to 0 if not required.

Further information

1. If a solution is rejected, the Optimizer will drop the found solution without updating any

attributes, including the cutoff value. To change the cutoff value when rejecting a solution, the

control MIPABSCUTOFF should be set instead.

2. When a node solution is rejected (isheuristic = 0), the node itself will be dropped without

further branching.

3. To retrieve the integer solution, use either problem.getlpsol or problem.getpresolvesol.

problem.getmipsol will not return the newly found solution because it has not been saved at this

point.

Related topics

problem.removecbpreintsol, problem.addcbintsol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 95

Reference Manual

problem.addcbprenode

Purpose

Declares a preprocess node callback function, called before the LP relaxation of a node has been

optimized, so the solution at the node will not be available. This callback function will be called

in addition to any callbacks already added by addcbprenode.

Synopsis

problem.addcbprenode (f_prenode, object, priority)

nodinfeas = f_prenode (my_prob, my_object)

Arguments

f_prenode The callback function, which takes three arguments, my_prob, my_object and

nodinfeas, and has no return value. This function is called before a node is

reoptimized and the node may be made infeasible by setting *nodinfeas to 1.

my_prob The problem passed to the callback function, f_prenode.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbprenode.

nodinfeas The feasibility status. If set to a nonzero value by the user, the current node will be

declared infeasible by the Optimizer.

object A user-deﬁned object to be passed to the callback function, f_prenode.

priority An integer that determines the order in which multiple preprocess node callbacks

will be invoked. The callback added with a higher priority will be called before a

callback with a lower priority. Set to 0 if not required.

Example

The following example notiﬁes the user before each node is processed:

prob.addcbprenode (preNode, None, 0)

prob.mipoptimize ("")

The callback function might resemble:

def preNode (prob, object):

return 0 # set to 1 if node is infeasible

Related topics

problem.removecbprenode, problem.addcbinfnode, problem.addcbintsol,

problem.addcbnodecutoff, problem.addcboptnode.

Fair Isaac Corporation Conﬁdential and Proprietary Information 96

Reference Manual

problem.addcbusersolnotify

Purpose

Declares a callback function to be called each time a solution added by problem.addmipsol has

been processed. This callback function will be called in addition to any callbacks already added by

addcbusersolnotify.

Synopsis

problem.addcbusersolnotify (f_usersolnotify, object, priority)

f_usersolnotify (my_prob, my_object, solname, status)

Arguments

f_usersolnotify The callback function which takes four arguments, my_prob, my_object, id and

status and has no return value.

my_prob The problem passed to the callback function, f_usersolnotify.

my_object The user-deﬁned object passed as object when setting up the callback with

addcbusersolnotify.

solname The string name assigned to the solution when it was loaded into the Optimizer

using problem.addmipsol.

status One of the following status values:

0 An error occured while processing the solution.

1 Solution is feasible.

2 Solution is feasible after reoptimizing with ﬁxed globals.

3 A local search heuristic was applied and a feasible solution discovered.

4 A local search heuristic was applied but a feasible solution was not found.

5 Solution is infeasible and a local search could not be applied.

6 Solution is partial and a local search could not be applied.

7 Failed to reoptimize the problem with globals ﬁxed to the provided

solution. Likely because a time or iteration limit was reached.

8 Solution is dropped. This can happen if the MIP problem is changed or

solved to completion before the solution could be processed.

object A user-deﬁned object to be passed to the callback function, f_usersolnotify.

priority An integer that determines the order in which multiple callbacks will be invoked.

The callback added with a higher priority will be called before a callback with a

lower priority. Set to 0 if not required.

Further information

If presolve is turned on, any solution added with problem.addmipsol will ﬁrst be presolved before

it can be checked. The value returned in status refers to the presolved solution, which might

have had values adjusted due to bound changes, ﬁxing of variables, etc.

Related topics

problem.removecbusersolnotify, problem.addmipsol.

Fair Isaac Corporation Conﬁdential and Proprietary Information 97

Reference Manual

problem.addcoefs

Purpose

Add non-linear coefﬁcients to the SLP problem

Synopsis

problem.addcoefs (rowindex, colindex, factor, fstart, parsed, type, value)

Arguments

rowindex Array holding the indices of rows for the coefﬁcient.

colindex Array holding the indices of columns for the coefﬁcient.

factor Array holding factor by which formula is scaled. If None, a value of 1.0 will be used.

FormulaStart Integer array of length nSLPCoef+1 holding the start position in the arrays Type

and Value of the formula for the coefﬁcients. FormulaStart should have an extra

entry containing the next position after the end of the last formula.

parsed Integer indicating whether the token arrays are formatted as internal unparsed

(parsed = False) or internal parsed reverse Polish (parsed = True).

type Array of token types providing the formula for each coefﬁcient.

value Array of values corresponding to the types in Type.

Example

Assume that the rows and columns of Prob are named Row1, Row2 ..., Col1, Col2 ..., respectively.

The following example adds coefﬁcients representing:

Col2 * Col3 + Col6 * Col2ˆ2 into Row1 and

Col2 ˆ 2 into Row3.

rowindex = [Row1,Row1,Row3]

colindex = [Col2,Col6,Col2]

formulastart = []

n = 0

ncoef = 0

formulastart[ncoef], ncoef = n, ncoef + 1

Type[n], Value[n], n = xslp_op_col, 3, n+1

Type[n], n = xslp_op_eof, n+1

formulastart[ncoef], ncoef = n, ncoef + 1

Type[n], Value[n], n = xslp_op_col, 2, n+1

Type[n], Value[n], n = xslp_op_op, xslp_MULTIPLY, n+1

Type[n], n = xslp_op_eof, n+1

formulastart[ncoef], ncoef = n, ncoef + 1

Type[n], Value[n], n = xslp_op_col, 2, n+1

Type[n], n = xslp_op_eof, n+1

formulastart [ncoef] = n

p.addcoefs (rowindex, colindex, None, formulastart, 1, Type, Value)

Fair Isaac Corporation Conﬁdential and Proprietary Information 98

Reference Manual

The ﬁrst coefﬁcient in Row1 is in Col2 and has the formula Col3, so it represents Col2 * Col3.

The second coefﬁcient in Row1 is in Col6 and has the formula Col2 * Col2 so it represents Col6 *

Col2ˆ2. The formulae are described as parsed (Parsed=1), so the formula is written as

Col2 Col2 *

rather than the unparsed form

Col2 * Col2

The last coefﬁcient, in Row3, is in Col2 and has the formula Col2, so it represents Col2 * Col2.

Further information

The j

coefﬁcient is made up of two parts: Factor and Formula. Factor is a constant multiplier,

which can be provided in the Factor array. If Xpress Nonlinear can identify a constant factor in

Formula, then it will use that as well, to minimize the size of the formula which has to be

calculated. Formula is made up of a list of tokens in Type and Value starting at formulastart[j].

The tokens follow the rules for parsed or unparsed formulae as indicated by the setting of

Parsed. The formula must be terminated with an xslp_op_eof token. If several coefﬁcients share

the same formula, they can have the same value in FormulaStart. For possible token types and

values see the chapter on "Formula Parsing".

The addcoef function loads additional items into the SLP problem. The corresponding loadcoefs

function deletes any existing items ﬁrst.

The behaviour for existing coefﬁcients is additive: the formula deﬁned in the parameters are

added to any existing formula coefﬁcients. However, due to performance considerations, such

duplications should be avoided when possible.

Related topics

problem.chgnlcoef, problem.chgccoef, problem.delcoefs, problem.getcoefformula,

problem.getccoef, problem.loadcoefs

Fair Isaac Corporation Conﬁdential and Proprietary Information 99

Reference Manual

problem.addcols

Purpose

Add columns to the problem after passing it to the Optimizer using the input routines.

Synopsis

problem.addcols (objx, mstart, mrwind, dmatval, bdl, bdu, names, types)

Arguments

objx Array containing the objective function coefﬁcients of the new columns.

mstart Array containing the offsets in the mrwind and dmatval arrays of the start of the

elements for each column.

mrwind Array containing the row indices for the elements in each column.

dmatval Array containing the element values.

bdl Array containing the lower bounds on the added columns.

bdu Array containing the upper bounds on the added columns.

names (optional) Array containing the names of the columns added.

types (optional) Array of characters containing the types of the newly added columns:

C indicates a continuous variable (default);

I indicates an integer variable;

B indicates a binary variable;

S indicates a semi-continuous variable;

R indicates a semi-continuous integer variable;

P indicates a partial integer variable.

Example

In this example, we consider the two problems:

(a) maximize: 2x + y (b) maximize: 2x + y + 3z

subject to: x + 4y ≤ 24 subject to: x + 4y + 2z ≤ 24

y ≤ 5 y + z ≤ 5

3x + y ≤ 20 3x + y ≤ 20

x + y ≤ 9 x + y + 3z ≤ 9

z ≤ 12

Using addcols, the following transforms (a) into (b):

p = xpress.problem ()

p.read ("example.lp")

# assume this problem has at least four constraints

p.addcols (obj = [3], mstart = [0,3], mrwind = [0, 1, 3],

matval = [2,1,3], bdl = [-xpress.infinity], bdu = [12],

names = [’john_cleese’], types = [’C’])

Further information

1. The constant xpress.infinity can be used to represent inﬁnite bounds.

2. If the columns are added to a MIP problem, then they will be continuous variables unless types is

speciﬁed. Use problem.chgcoltype to impose integrality conditions on such new columns.

Related topics

problem.addrows, problem.chgcoltype.

Fair Isaac Corporation Conﬁdential and Proprietary Information 100

Reference Manual

problem.addConstraint

Purpose

Adds one or more constraints to the problem.

Synopsis

problem.addConstraint (c1, c2, ...)

Argument

c1,c2... Constraints or list/tuples/array of constraints created with the xpress.constraint()

call.

Example

N = 20

x = [xpress.var () for i in range (N)]

c = [x[i] <= x[i+1] for i in range (N-1)]

c2 = x[0] >= x[19]

p = xpress.problem ()

p.addVariable (x)

p.addConstraint (x[2] == x[4])

p.addConstraint (c, c2)

Further information

All arguments can be single constraints or lists, tuples, or NumPy arrays of constraints created as

xpress.constraint objects. Arguments do not need to be declared prior to the call.

Fair Isaac Corporation Conﬁdential and Proprietary Information 101

Reference Manual

problem.addcuts

Purpose

Adds cuts directly to the matrix at the current node. Any cuts added to the matrix at the current

node and not deleted at the current node will be automatically added to the cut pool. The cuts

added to the cut pool will be automatically restored at descendant nodes.

Synopsis

problem.addcuts (mtype, rtype, rhs, mstart, mcols, matval)

Arguments

mtype Array containing the user assigned cut types. The cut types can be any integer

chosen by the user, and are used to identify the cuts in other cut manager routines

using user supplied parameters. The cut type can be interpreted as an integer or a

bitmap - see problem.delcuts.

rtype Character array of length ncuts containing the row types:

L indicates a ≤ row;

G indicates ≥ row;

E indicates an = row.

rhs Array of length ncuts containing the right hand side elements for the cuts.

mstart Array containing offset into the mcols and dmatval arrays indicating the start of

each cut. This array is of length ncuts+1 with the last element, mstart[ncuts],

being where cut ncuts+1 would start.

cols Array of length mstart[ncuts] containing the column indices in the cuts.

matval Array of length mstart[ncuts] containing the matrix values for the cuts.

Further information

1. The columns and elements of the cuts must be stored contiguously in the mcols and dmatval

arrays passed to addcuts. The starting point of each cut must be stored in the mstart array. To

determine the length of the ﬁnal cut, the mstart array must be of length ncuts+1 with the last

element of this array containing the position in mcols and dmatval where the cut ncuts+1 would

start. mstart[ncuts] denotes the number of nonzeros in the added cuts.

2. The cuts added to the matrix are always added at the end of the matrix and the number of rows

is always set to the original number of cuts added. If ncuts have been added, then the rows

0,...,ROWS-ncuts-1 are the original rows, whilst the rows ROWS-ncuts,...,ROWS-1 are the added cuts.

The number of cuts can be found by consulting the CUTS problem attribute.

Related topics

problem.addrows, problem.delcpcuts, problem.delcuts, problem.getcpcutlist,

problem.getcutlist, problem.loadcuts, problem.storecuts, Section "Working with the cut

manager" of the Xpress Optimizer reference manual.

Fair Isaac Corporation Conﬁdential and Proprietary Information 102

Reference Manual

problem.adddfs

Purpose

Add a set of distribution factors

Synopsis

problem.adddfs (colindex, rowindex, value)

Arguments

colindex Array of indices of columns whose distribution factor is to be changed.

rowindex Array of indices of the rows where each distribution factor applies.

value Array holding the new values of the distribution factors.

Example

The following example adds distribution factors as follows:

column 282 in row 134 = 0.1

column 282 in row 136 = 0.15

column 285 in row 133 = 1.0.

colindex = [282, 282, 285]

rowindex = [134, 136, 133]

value = [0.1, 0.15, 1]

p.adddfs (colindex,rowindex,value)

Further information

The distribution factor of a column in a row is the matrix coefﬁcient of the corresponding delta

vector in the row. Distribution factors are used in conventional recursion models, and are

essentially normalized ﬁrst-order derivatives. Xpress SLP can accept distribution factors instead of

initial values, provided that the values of the variables involved can all be calculated after

optimization using determining rows, or by a callback.

The problem.adddfs functions load additional items into the SLP problem. The corresponding

problem.loaddfs functions delete any existing items ﬁrst.

Related topics

problem.chgdf, problem.getdf, problem.loaddfs

Fair Isaac Corporation Conﬁdential and Proprietary Information 103

Reference Manual

problem.addIndicator

Purpose

Adds one or more indicator constraints to the problem.

Synopsis

problem.addIndicator (c1, c2, ...)

Argument

c1,c2... Tuples containing an indicator constraints, or list/tuples/array of tuples containing a

binary condition and a constraint.

Example

x = xpress.var (vartype = xpress.binary)

y = xpress.var (lb = 10, ub = 20)

z = xpress.var ()

ind1 = (x==1, y+z <= 40)

p = xpress.problem ()

p.addVariable (x,y,z)

p.addIndicator (ind1)

Further information

All arguments can be single indicator constraints or lists, tuples, or NumPy arrays created as

indicator constraints. An indicator constraint is a tuple of two elements, the ﬁrst being a

condition (i.e. a binary variable being 0 or 1) and the second being the constraint.

Fair Isaac Corporation Conﬁdential and Proprietary Information 104

Reference Manual

problem.addmipsol

Purpose

Adds a new feasible, infeasible or partial MIP solution for the problem to the Optimizer.

Synopsis

problem.addmipsol (mipsolval, mipsolcol, solname)

Arguments

mipsolval Array containing solution values.

mipsolcol Optional integer array containing the column indices for the solution values

provided in mipsolval. It is optional when the length of mipsolval is equal to COLS,

in which case it is assumed that mipsolval provides a complete solution vector.

solname An optional name to associate with the solution.

Further information

1. The function returns immediately after passing the solution to the Optimizer. The solution is

placed in a pool until the Optimizer is able to analyze the solution during a MIP solve.

2. If the provided solution is found to be infeasible, a limited local search heuristic will be run in an

attempt to ﬁnd a close feasible integer solution.

3. If a partial solution is provided, global columns will be ﬁxed to any provided values and a limited

local search will be run in an attempt to ﬁnd integer feasible values for the remaining unspeciﬁed

columns. Values provided for continuous column in partial solutions are currently ignored.

4. The problem.addcbusersolnotify callback function can be used to discover the outcome of a

loaded solution. The optional name provided as solname will be returned in the callback function.

5. If one or more solutions are loaded during the problem.addcboptnode callback, the Optimizer will

process all loaded solutions and ﬁre the callback again. This will be repeated as long as new

solutions are loaded during the callback.

Related topics

problem.addcbusersolnotify, problem.addcboptnode.

Fair Isaac Corporation Conﬁdential and Proprietary Information 105

Reference Manual

problem.addqmatrix

Purpose

Adds a new quadratic matrix into a row deﬁned by triplets.

Synopsis

problem.addqmatrix (irow, mqc1, mqc2, dqe)

Arguments

irow Index of the row where the quadratic matrix is to be added.

mqc1 First index in the triplets.

mqc2 Second index in the triplets.

dqe Coefﬁcients in the triplets.

Further information

1. The triplets should deﬁne the whole quadratic expression. This means that to add x

+ 4xy the dqe

arrays shall contain the coefﬁcients 1 and 4.

2. The matrix deﬁned by mqc1, mqc2 and dqe should be positive semi-deﬁnite for ≤ and negative

semi-deﬁnite for ≥ rows.

3. The row must not be an equality or a ranged row.

Related topics

problem.loadproblem, problem.getqrowcoeff, problem.chgqrowcoeff, problem.getqrowqmatrix,

problem.getqrowqmatrixtriplets, problem.getqrows, problem.chgqobj, problem.chgmqobj,

problem.getqobj.

Fair Isaac Corporation Conﬁdential and Proprietary Information 106

Reference Manual

problem.addrows

Purpose

Adds rows and their coefﬁcient to the problem.

Synopsis

problem.addrows (qrtype, rhs, mstart, mclind, dmatval, range = None, names = None)

Arguments

qrtype Character array containing the row types:

L indicates a ≤ row;

G indicates ≥ row;

E indicates an = row.

R indicates a range constraint;

N indicates a nonbinding constraint.

rhs Array containing the right hand side elements.

mstart Array containing the offsets in the mclind and dmatval arrays of the start of the

elements for each row.

mclind Array containing the (contiguous) column indices for the elements in each row.

dmatval Array containing the (contiguous) element values.

range (optional) Array containing the row range elements. Optional. The values in the

range array will only be read for R type rows. The entries for other type rows will

be ignored.

names (optional) Array of names to be assigned to each new row.

Example

Suppose the current problem is:

maximize: 2x + y + 3z

subject to: x + 4y + 2z ≤ 24

y + z ≤ 5

3x + y ≤ 20

x + y + 3z ≤ 9

Then the following adds the row 8x + 9y + 10z ≤ 25 to the problem and names it NewRow:

p = xpress.problem ()

p.addrows ([’L’], [25], None, [0,3], [0,1,2],

dmatval = [8, 9, 10], names = [’NewRow’])

Further information

Range rows are automatically converted to type L, with an upper bound in the slack. This must be

taken into consideration, when retrieving row type, right–hand side values or range information

for rows.

Related topics

problem.addcols, problem.addcuts.

Fair Isaac Corporation Conﬁdential and Proprietary Information 107

Reference Manual

problem.addSOS

Purpose

Adds one or more Special Ordered Set (SOS) to the problem.

Synopsis

problem.addSOS (s1, s2, ...)

Argument

s1,s2... Special Ordered Sets deﬁned prior to the call or (see example below) deﬁned

directly in the call.

Example

N = 20

x = [xpress.var () for i in range (N)]

p = xpress.problem ()

p.addVariable (x)

s = xpress.sos ([x], [i+2 for i in range (N)])

p.addSOS (s)

p.addSOS ([x[0], x[2]], [4,6])

Further information

All arguments can be single SOSs or lists, tuples, or NumPy arrays of SOSs created as xpress.sos

objects. As for constraints, a SOS does not need to be declared prior to being added as an

argument.

Fair Isaac Corporation Conﬁdential and Proprietary Information 108

Reference Manual

problem.addtolsets

Purpose

Add sets of standard tolerance values to an SLP problem

Synopsis

problem.addtolsets (tol)

Argument

slptol Array of 9h elements containing the 9 tolerance values for each set in order.

Example

The following example creates two tolerance sets: the ﬁrst has values of 0.005 for all tolerances;

the second has values of 0.001 for relative tolerances (numbers 2,4,6,8), values of 0.01 for

absolute tolerances (numbers 1,3,5,7) and zero for the closure tolerance (number 0).

tol = 9*[0.005]+[0]+[0.01,0.001]*4

p.addtolsets (tol)

Further information

A tolerance set is an array of 9 values containing the following tolerances:

Entry / Bit Tolerance XSLP constant XSLP bit constant

0 Closure tolerance (TC) xslp_TOLSET_TC xslp_TOLSETBIT_TC

1 Absolute delta tolerance (TA) xslp_TOLSET_TA xslp_TOLSETBIT_TA

2 Relative delta tolerance (RA) xslp_TOLSET_RA xslp_TOLSETBIT_RA

3 Absolute coefﬁcient tolerance (TM) xslp_TOLSET_TM xslp_TOLSETBIT_TM

4 Relative coefﬁcient tolerance (RM) xslp_TOLSET_RM xslp_TOLSETBIT_RM

5 Absolute impact tolerance (TI) xslp_TOLSET_TI xslp_TOLSETBIT_TI

6 Relative impact tolerance (RI) xslp_TOLSET_RI xslp_TOLSETBIT_RI

7 Absolute slack tolerance (TS) xslp_TOLSET_TS xslp_TOLSETBIT_TS

8 Relative slack tolerance (RS) xslp_TOLSET_RS xslp_TOLSETBIT_RS

The xslp_TOLSET constants can be used to access the corresponding entry in the value arrays,

while the xslp_TOLSETBIT constants are used to set or retrieve which tolerance values are used for

a given SLP variable. Once created, a tolerance set can be used to set the tolerances for any SLP

variable. If a tolerance value is zero, then the default tolerance will be used instead. To force the

use of a zero tolerance, use the problem.chgtolset function and set the Status variable

appropriately. See the section "Convergence criteria" of the SLP Reference Manual for a fuller

description of tolerances and their uses. The problem.addtolsets functions load additional items

into the SLP problem. The corresponding problem.loadtolsets functions delete any existing

items ﬁrst.

Related topics

problem.chgtolset, problem.deltolsets, problem.gettolset, problem.loadtolsets

Fair Isaac Corporation Conﬁdential and Proprietary Information 109

Reference Manual

problem.addVariable

Purpose

Adds one or more variables to the problem.

Synopsis

problem.addVariable (v1, v2, ...)

Argument

v1,v2... Variables or list/tuples/array of variables created with the xpress.var() call.

Example

x = xpress.var (vartype = xpress.binary)

Y = [xpress.var () for i in range (20)]

p = xpress.problem ()

p.addVariable (x, Y)

Further information

All arguments can be single variables or lists, tuples, or NumPy arrays of variables created as

xpress.var objects.

Fair Isaac Corporation Conﬁdential and Proprietary Information 110

Reference Manual

problem.addvars

Purpose

Add SLP variables deﬁned as matrix columns to an SLP problem

Synopsis

problem.addvars (colindex, vartype, detrow, seqnum, tolindex, initvalue, stepbound)

Arguments

colindex Integer array holding the index of the matrix column corresponding to each SLP

variable.

vartype Bitmap giving information about the SLP variable as follows:

Bit 1 Variable has a delta vector;

Bit 2 Variable has an initial value;

Bit 14 Variable is the reserved "=" column;

May be None if not required.

detrow Integer array holding the index of the determining row for each SLP variable (a

negative value means there is no determining row)

May be None if not required.

seqnum Integer array holding the index sequence number for cascading for each SLP

variable (a zero value means there is no pre-deﬁned order for this variable)

May be None if not required.

tolindex Integer array holding the index of the tolerance set for each SLP variable (a zero

value means the default tolerances are used)

May be None if not required.

initvalue Double array holding the initial value for each SLP variable (use the VarType bit

map to indicate if a value is being provided)

May be None if not required.

stepbound Double array holding the initial step bound size for each SLP variable (a zero value

means that no initial step bound size has been speciﬁed). If a value of

xpress.infinity is used for a value in stepbound, the delta will never have step

bounds applied, and will almost always be regarded as converged.

May be None if not required.

Example

The following example loads two SLP variables into the problem. They correspond to columns 23

and 25 of the underlying LP problem. Column 25 has an initial value of 1.42; column 23 has no

speciﬁc initial value

colindex = [23,25]

vartype = [0,2]

initvalue = [0,1.42]

p.addvars (colindex, vartype, None, None, None, initvalue, None)

initvalue is not set for the ﬁrst variable, because it is not used (vartype = 0). Bit 1 of vartype is

set for the second variable to indicate that the initial value has been set. The arrays for

determining rows, sequence numbers, tolerance sets and step bounds are not used at all, and so

have been passed to the function as None.

Further information

The addvars functions load additional items into the SLP problem. The corresponding loadvars

functions delete any existing items ﬁrst.

Related topics

problem.chgvar, problem.delvars, problem.getvar, problem.loadvars

Fair Isaac Corporation Conﬁdential and Proprietary Information 111

Reference Manual

problem.basisstability

Purpose

Returns various measures for the stability of the current basis, including the basis condition

number.

Synopsis

x = problem.basisstability (type, norm, ifscaled)

Arguments

type 0 Condition number of the basis.

1 Stability measure for the solution relative to the current basis.

2 Stability measure for the duals relative to the current basis.

3 Stability measure for the right hand side relative to the current basis.

4 Stability measure for the basic part of the objective relative to the current

basis.

norm 0 Use the inﬁnity norm.

1 Use the 1 norm.

2 Use the Euclidian norm for vectors and the Frobenius norm for matrices.

ifscaled If the stability values are to be calculated in the scaled or the unscaled matrix.

Further information

1. The condition number (type = 0) of an invertible matrix is the norm of the matrix multiplied with

the norm of its inverse. This number is an indication of how accurate the solution can be

calculated and how sensitive it is to small changes in the data. The larger the condition number

is, the less accurate the solution is likely to become.

2. The stability measures (type = 1...4) are using the original matrix and the basis to recalculate the

various vectors related to the solution and the duals. The returned stability measure is the norm

of the difference of the recalculated vector to the original one.

Fair Isaac Corporation Conﬁdential and Proprietary Information 112

Reference Manual

problem.btran

Purpose

Post-multiplies a (row) vector provided by the user by the inverse of the current basis.

Synopsis

problem.btran (vec)

Argument

vec Array of length ROWS containing the values by which the basis inverse is to be

multiplied. The transformed values will also be returned in this array.

Example

Get the (unscaled) tableau row z of constraint number irow, assuming that all arrays have been

dimensioned.

y = [0,1,0,0]

p.btran (y)

print ("btran result:", y)

Further information

If the problem is in a presolved state, btran works with the basis for the presolved problem.

Related topics

problem.ftran.

Fair Isaac Corporation Conﬁdential and Proprietary Information 113

Reference Manual

problem.calcobjective

Purpose

Returns the objective value of a given solution.

Synopsis

objval = problem.calcobjective (solution)

Argument

solution Array of length COLS that holds the solution.

Further information

The calculations are always carried out in the original problem, even if the problem is currently

presolved.

Related topics

problem.calcslacks, problem.calcreducedcosts.

Fair Isaac Corporation Conﬁdential and Proprietary Information 114

Reference Manual

problem.calcreducedcosts

Purpose

Returns the reduced cost values for a given (row) dual solution.

Synopsis

problem.calcreducedcosts (duals, solution, calculateddjs)

Arguments

duals Array of length ROWS that holds the dual solution to calculate the reduced costs for.

solution Optional array of length COLS that holds the primal solution. This is necessary for

quadratic problems.

calculateddjs Array of length COLS in which the calculated reduced costs are returned.

Example

p = xpress.problem ()

p.read ("silly_walks.lp") # assume problem has 4 constraints

dj = []

p.calcreducedcosts ([0,1,1,1], None, dj)

print ("red. cost:", dj)

Further information

1. The calculations are always carried out in the original problem, even if the problem is currently

presolved.

2. If using the function during a solve (e.g. from a callback), use ORIGINALCOLS and

ORIGINALROWS to retrieve the non-presolved dimensions of the problem.

Related topics

problem.calcslacks, problem.calcobjective.

Fair Isaac Corporation Conﬁdential and Proprietary Information 115

Reference Manual

problem.calcslacks

Purpose

Calculates the row slack values for a given solution.

Synopsis

problem.calcslacks (solution, calculatedslacks)

Arguments

solution Array of length COLS that holds the solution to calculate the slacks for.

calculatedslacks Array of length ROWS in which the calculated row slacks are returned.

Further information

1. The calculations are always carried out in the original problem, even if the problem is currently

presolved.

2. If using the function during a solve (e.g. from a callback), use ORIGINALCOLS and

ORIGINALROWS to retrieve the non-presolved dimensions of the problem.

Related topics

problem.calcreducedcosts, problem.calcobjective.

Fair Isaac Corporation Conﬁdential and Proprietary Information 116

Reference Manual

problem.calcsolinfo

Purpose

Returns the required property of a solution, like maximum infeasibility of a given primal and dual

solution.

Synopsis

val = problem.calcsolinfo (solution, dual, property)

Arguments

solution Array of length COLS that holds the solution.

dual Array of length ROWS that holds the dual solution.

property xpress.solinfo_absprimalinfeas absolute primal infeasibility.

xpress.solinfo_relprimalinfeas relative primal infeasibility.

xpress.solinfo_absdualinfeas absolute dual infeasibility.

xpress.solinfo_reldualinfeas relative dual infeasibility.

xpress.solinfo_maxmipfractional absolute MIP infeasibility

(fractionality).

Further information

The calculations are always carried out in the original problem, even if the problem is currently

presolved.

Related topics

problem.calcslacks, problem.calcobjective, problem.calcreducedcosts.

Fair Isaac Corporation Conﬁdential and Proprietary Information 117

Reference Manual

problem.cascade

Purpose

Re-calculate consistent values for SLP variables. based on the current values of the remaining

variables

Synopsis

problem.cascade ()

Example

The following example changes the solution value for column 91, and then re-calculates the

values of those dependent on it.

colnum = 91

(a,b,c,d,e,f,value,h,i,j,k,l,m,n,o) = p.getvar (colnum)

value += 1.42;

p.chgvar (colnum, None, None, None, None,

None, None, value, None, None, None,

None)

p.cascade ()

problem.getvar and problem.chgvar are being used to get and change the current value of a

single variable. Provided no other values have been changed since the last execution of cascade,

values will be changed only for variables which depend on column 91.

Further information

See the section on cascading for an extended discussion of the types of cascading which can be

performed.

cascade is called automatically during the SLP iteration process and so it is not normally necessary

to perform an explicit cascade calculation.

The variables are re-calculated in accordance with the order generated by problem.cascadeorder.

Related topics

problem.cascadeorder

Fair Isaac Corporation Conﬁdential and Proprietary Information 118

Reference Manual

problem.cascadeorder

Purpose

Establish a re-calculation sequence for SLP variables with determining rows.

Synopsis

problem.cascadeorder ()

Example

Assuming that all variables are SLP variables, the following example sets default values for the

variables, creates the re-calculation order and then calls problem.cascade to calculate consistent

values for the dependent variables.

int ColNum;

for colnum in range (1, nCol):

p.chgvar (colnum, None, None, None, None,

None, None, [DefaultValue [ColNum]], None, None, None,

None)

p.cascadeorder ()

p.cascade ()

Further information

cascadeorder is called automatically at the start of the SLP iteration process and so it is not

normally necessary to perform an explicit cascade ordering.

Related topics

problem.cascade

Fair Isaac Corporation Conﬁdential and Proprietary Information 119

Reference Manual

problem.chgbounds

Purpose

Changes the bounds on columns in the problem.

Synopsis

problem.chgbounds (mindex, qbtype, bnd)

Arguments

mindex Array containing the indices of the columns on which the bounds will change.

qbtype Character array indicating the type of bound to change:

U indicates a change in the upper bound;

L indicates a change in the lower bound;

B indicates a change in both bounds, i.e. the column is ﬁxed.

bnd Array giving the new bound values.

Example

The following changes column 0 of the current problem to have an upper bound of 0.5:

p.chgbounds ([0,1,2],[’L’,’U’,’B’],[1,2,3])

Further information

1. A column index may appear twice in the mindex array so it is possible to change both the upper

and lower bounds on a variable in one go.

2. chgbounds may be applied to the problem in a presolved state, in which case it expects references

to the presolved problem.

3. The double constant xpress.infinity can be used to represent plus and minus inﬁnity in the

bound (bnd) array.

4. If the upper bound on a binary variable is changed to be greater than 1 or the lower bound is

changed to be less than 0 then the variable will become an integer variable.

Related topics

problem.getlb, problem.getub.

Fair Isaac Corporation Conﬁdential and Proprietary Information 120

Reference Manual

problem.chgcoef

Purpose

Changes a single coefﬁcient in the problem. If the coefﬁcient does not already exist, a new

coefﬁcient will be added to the problem. If many coefﬁcients are being added to a row of the

problem, it may be more efﬁcient to delete the old row and add a new row.

Synopsis

problem.chgcoef (irow, icol, dval)

Arguments

irow Row index for the coefﬁcient.

icol Column index for the coefﬁcient.

dval New value for the coefﬁcient. If dval is zero, any existing coefﬁcient will be

deleted.

Example

In the following, the constraint is introduced in the problem and then its linear coefﬁcient for x is

changed to 3:

p = xpress.problem ()

x = xpress.var ()

c = x + x**2 <= 3

p.addVariable (x)

p.addConstraint (c)

p.chgcoef (c,x,3)

Further information

problem.chgmcoef is more efﬁcient than multiple calls to chgcoef and should be used in its place

in such circumstances.

Related topics

problem.addcols, problem.addrows, problem.chgmcoef, problem.chgmqobj, problem.chgobj,

problem.chgqobj, problem.chgrhs, problem.getcols, problem.getrows.

Fair Isaac Corporation Conﬁdential and Proprietary Information 121

Reference Manual

problem.chgcoltype

Purpose

Changes the type of a column in the problem.

Synopsis

problem.chgcoltype (mindex, qctype)

Arguments

mindex Array containing the indices of the columns.

qctype Character array giving the new column types:

C indicates a continuous column;

B indicates a binary column;

I indicates an integer column.

S indicates a semi–continuous column. The semi–continuous lower bound

will be set to 1.0.

R indicates a semi–integer column. The semi–integer lower bound will be set

to 1.0.

P indicates a partial integer column. The partial integer bound will be set to

1.0.

Example

The following changes the type of variable x from binary to integer:

p = xpress.problem ()

x = xpress.var (vartype = xp.binary)

p.addVariable (x)

p.chgcoltype ([x],[’I’])

Further information

1. The column types can only be changed before the global search is started.

2. Calling chgcoltype to change any variable into a binary variable causes the bounds previously

deﬁned for the variable to be deleted and replaced by bounds of 0 and 1.

3. Calling chgcoltype to change a continuous variable into an integer variable cause its lower

bound to be rounded up to the nearest integer value and its upper bound to be rounded down

to the nearest integer value.

Related topics

problem.addcols, problem.chgrowtype, problem.getcoltype.

Fair Isaac Corporation Conﬁdential and Proprietary Information 122

Reference Manual

problem.chgcascadenlimit

Purpose

Set a variable speciﬁc cascade iteration limit

Synopsis

problem.chgcascadenlimit (icol, cascadenlimit)

Arguments

icol The index of the column corresponding to the SLP variable for which the cascading

limit is to be imposed.

cascadenlimit The new cascading iteration limit.

Further information

A value set by this function will overwrite the value of the control xslp_cascadenlimit for this

variable. To remove any previous value set by this function, use an iteration limit of 0.

Related topics

problem.cascadeorder

Fair Isaac Corporation Conﬁdential and Proprietary Information 123

Reference Manual

problem.chgccoef

Purpose

Add or change a single matrix coefﬁcient using a character string for the formula

Synopsis

problem.chgccoef (rowindex, colindex, factor, formula)

Arguments

rowindex The index of the matrix row for the coefﬁcient.

colindex The index of the matrix column for the coefﬁcient.

factor Constant multiplier for the formula. If factor is None, a value of 1.0 will be used.

Formula Character string holding the formula, with the tokens separated by spaces.

Example

Assuming that the columns of the matrix are named Col1, Col2, etc, the following example puts

the formula 2.5*sin(Col1) into the coefﬁcient in row 1, column 3.

Formula = "sin ( Col1 )"

Factor = 2.5

p.chgccoef (1, 3, Factor, Formula)

Note that all the tokens in the formula (including mathematical operators and separators) are

separated by one or more spaces.

Further information

If the coefﬁcient already exists as a constant or formula, it will be changed into the new

coefﬁcient. If it does not exist, it will be added to the problem.

A coefﬁcient is made up of two parts: Factor and Formula. Factor is a constant multiplier which

can be provided in the Factor variable. If Xpress Nonlinear can identify a constant factor in the

Formula, then it will use that as well, to minimize the size of the formula which has to be

calculated.

This function can only be used if all the operands in the formula can be correctly identiﬁed as

constants, existing columns, character variables or functions. Therefore, if a formula refers to a

new column, that new item must be added to the Xpress Nonlinear problem ﬁrst.

Related topics

problem.addcoefs, problem.delcoef, problem.chgnlcoef, problem.getcoefformula,

problem.loadcoefs

Fair Isaac Corporation Conﬁdential and Proprietary Information 124

Reference Manual

problem.chgdeltatype

Purpose

Changes the type of the delta assigned to a nonlinear variable

Synopsis

problem.chgdeltatype (vars, deltatypes, values)

Arguments

Vars Indices of the variables to change the deltas for.

DeltaTypes Type if the delta variable:

0 Differentiable variable, default.

1 Variable deﬁned over the grid size given in values.

2 Variable where a minimum perturbation size given in values may be

required before a signiﬁcant change in the problem is achieved.

3 Variable where a meaningful step size should automatically be

detected, with an upper limit given in values.

Values Grid or minimum step sizes for the variables.

Further information

Changing the delta type of a variables makes the variable nonlinear.

Related topics

Fair Isaac Corporation Conﬁdential and Proprietary Information 125

Reference Manual

problem.chgdf

Purpose

Set or change a distribution factor

Synopsis

problem.chgdf (colindex, rowindex, value)

Arguments

colindex The index of the column whose distribution factor is to be set or changed.

rowindex The index of the row where the distribution applies.

value Address of a double precision variable holding the new value of the distribution

factor. May be None if not required.

Example

The following example retrieves the value of the distribution factor for column 282 in row 134

and changes it to be twice as large.

value = p.getdf (282,134)

value *= 2;

p.chgdf (282,134,value)

Further information

The distribution factor of a column in a row is the matrix coefﬁcient of the corresponding delta

vector in the row. Distribution factors are used in conventional recursion models, and are

essentially normalized ﬁrst-order derivatives. Xpress Nonlinear can accept distribution factors

instead of initial values, provided that the values of the variables involved can all be calculated

after optimization using determining rows, or by a callback.

Related topics

problem.adddfs, problem.getdf, problem.loaddfs

Fair Isaac Corporation Conﬁdential and Proprietary Information 126

Reference Manual

problem.chgglblimit

Purpose

Changes semi-continuous or semi-integer lower bounds, or upper limits on partial integers.

Synopsis

problem.chgglblimit (mindex, dlimit)

Arguments

mindex Array containing the indices of the semi-continuous, semi-integer or partial integer

columns that should have their limits changed.

dlimit Array giving the new limit values.

Further information

1. The new limits are not allowed to be negative.

2. Partial integer limits can be at most 2

Related topics

problem.chgcoltype, problem.getglobal.

Fair Isaac Corporation Conﬁdential and Proprietary Information 127

Reference Manual

problem.chgmcoef

Purpose

Change multiple coefﬁcients in the problem. The coefﬁcients that do not exist yet will be added

to the problem. If many coefﬁcients are being added to a row of the matrix, it may be more

efﬁcient to delete the old row of the matrix and add a new one.

Synopsis

problem.chgmcoef (mrow, mcol, dval)

Arguments

mrow Array containing the row indices of the coefﬁcients to be changed.

mcol Array containing the column indices of the coefﬁcients to be changed.

dval Array containing the new coefﬁcient values. If an element of dval is zero, the

coefﬁcient will be deleted.

Example

con1 = x + y + z <= 2

con2 = x + y >= 1

con3 = x + 3*y = 1

p.addVariable (x,y,z)

p.addConstraint (con1, con2, con3)

p.chgmcoef ([con1,con1,con1,con2,con3], [x,y,z,x,x], [-2, -3, -3.2, 1, 3])

This changes ﬁve coefﬁcients, three of which in the ﬁrst constraint and one in each of the second

and third constraints.

Further information

chgmcoef is more efﬁcient than repeated calls to problem.chgcoef and should be used in its place

if many coefﬁcients are to be changed.

Related topics

problem.chgcoef, problem.chgmqobj, problem.chgobj, problem.chgqobj, problem.chgrhs,

problem.getcols, problem.getrhs.

Fair Isaac Corporation Conﬁdential and Proprietary Information 128

Reference Manual

problem.chgmqobj

Purpose

Change multiple quadratic coefﬁcients in the objective function. If any of the coefﬁcients does

not exist already, new coefﬁcients will be added to the objective function.

Synopsis

problem.chgmqobj (mqcol1, mqcol2, dval)

Arguments

mqcol1 Array containing the column index of the ﬁrst variable in each quadratic term.

mqcol2 Array containing the column index of the second variable in each quadratic term.

dval New values for the coefﬁcients. If an entry in dval is 0, the corresponding entry will

be deleted. These are the coefﬁcients of the lower triangular part of the Hessian of

the objective function.

Example

The following code results in an objective function with terms: [4x

+ 6x

p.chgmqobj ([x1,x1], [x1,x2], [4,3])

Further information

1. The columns in the arrays mqcol1 and mqcol2 must already exist in the matrix. If the columns do

not exist, they must be added.

2. chgmqobj is more efﬁcient than repeated calls to problem.chgqobj and should be used in its place

when several coefﬁcients are to be changed.

Related topics

problem.chgcoef, problem.chgmcoef, problem.chgobj, problem.chgqobj, problem.getqobj.

Fair Isaac Corporation Conﬁdential and Proprietary Information 129

Reference Manual

problem.chgnlcoef

Purpose

Add or change a single matrix coefﬁcient using a parsed or unparsed formula

Synopsis

problem.chgnlcoef (rowindex, colindex, factor, parsed, type, value)

Arguments

rowindex The index of the matrix row for the coefﬁcient.

colindex The index of the matrix column for the coefﬁcient.

factor Address of a double precision variable holding the constant multiplier for the

formula. If Factor is None, a value of 1.0 will be used.

parsed Integer indicating the whether the token arrays are formatted as internal unparsed

(parsed=False) or internal parsed reverse Polish (parsed=True).

type Array of token types providing the description and formula for each item.

value Array of values corresponding to the types in type.

Example

Assuming that the columns of the matrix are named Col1, Col2, etc, the following example puts

the formula 2.5*sin(Col1) into the coefﬁcient in row 1, column 3.

type = [xp.xslp_op_ifun, xp.xslp_op_var, xp.xslp_op_rb, xp.xslp_op_eof]

value = [xp.xslp_ifun_sin, 1, 0, 0]

Factor = 2.5

p.chgnlcoef (1, 3, Factor, 0, type, value)

problem.getindex is used to retrieve the index for the internal function sin. The "nocase" version

matches the function name regardless of the (upper or lower) case of the name. Tokens of type

xpress.xslp_op_var always count from 1, so Col1 is 1. The formula is written in unparsed form

(parsed = 0) and so it is provided as tokens in the same order as they would appear if the formula

were written in character form.

Further information

If the coefﬁcient already exists as a constant or formula, it will be changed into the new

coefﬁcient. If it does not exist, it will be added to the problem.

A coefﬁcient is made up of two parts: Factor and Formula. Factor is a constant multiplier which

can be provided in the factor variable. If Xpress Nonlinear can identify a constant factor in the

Formula, then it will use that as well, to minimize the size of the formula which has to be

calculated.

Related topics

problem.addcoefs, problem.chgccoef, problem.delcoefs, problem.getcoefformula,

problem.loadcoefs

Fair Isaac Corporation Conﬁdential and Proprietary Information 130

Reference Manual

problem.chgobj

Purpose

Change the objective function coefﬁcients.

Synopsis

problem.chgobj (mindex, obj)

Arguments

mindex Arraycontaining the indices of the columns on which the range elements will

change. An index of -1 indicates that the ﬁxed part of the objective function on

the right hand side should change.

obj Array giving the new objective function coefﬁcient.

Example

Changing three coefﬁcients of the objective function with chgobj:

p.chgobj ([x1,x2,x3,-1], [3.5, -2, 0, 224])

Further information

The value of the ﬁxed part of the objective function can be obtained using the OBJRHS problem

attribute.

Related topics

problem.chgcoef, problem.chgmcoef, problem.chgmqobj, problem.chgqobj, problem.getobj.

Fair Isaac Corporation Conﬁdential and Proprietary Information 131

Reference Manual

problem.chgobjsense

Purpose

Changes the problem’s objective function sense to minimize or maximize.

Synopsis

problem.chgobjsense (sense)

Argument

objsense xpress.minimize or xpress.maximize to change into a minimization or

maximization problem, respectively.

Example

Changing three coefﬁcients of the objective function with chgobj:

p.chgobjsense (xpress.maximize) # optimize in this general direction

Related topics

problem.lpoptimize, problem.mipoptimize.

Fair Isaac Corporation Conﬁdential and Proprietary Information 132

Reference Manual

problem.chgqobj

Purpose

Change a single quadratic coefﬁcient in the objective function corresponding to the variable pair

(icol,jcol) of the Hessian matrix.

Synopsis

problem.chgqobj (icol, jcol, dval)

Arguments

icol Column index for the ﬁrst variable in the quadratic term.

jcol Column index for the second variable in the quadratic term.

dval New value for the coefﬁcient in the quadratic Hessian matrix. If an entry in dval is

0, the corresponding entry will be deleted.

Example

The following code adds the terms [6x

+ 3x

] / 2 to the objective function:

p.chgqobj (x1, x1, 6)

p.chgqobj (x1, x2, 3)

Further information

1. The columns icol and jcol must already exist in the matrix..

2. If icol is not equal to jcol, then both the matrix elements (icol, jcol) and (jcol, icol) are

changed to leave the Hessian symmetric.

Related topics

problem.chgcoef, problem.chgmcoef, problem.chgmqobj, problem.chgobj, problem.getqobj.

Fair Isaac Corporation Conﬁdential and Proprietary Information 133

Reference Manual

problem.chgqrowcoeff

Purpose

Changes a single quadratic coefﬁcient in a row.

Synopsis

problem.chgqrowcoeff (irow, icol, jcol, dval)

Arguments

irow Index of the row where the quadratic matrix is to be changed.

icol First index of the coefﬁcient to be changed.

jcol Second index of the coefﬁcient to be changed.

dval The new coefﬁcient.

Further information

1. This function may be used to add new nonzero coefﬁcients, or even to deﬁne the whole

quadratic expression with it. Doing that, however, is signiﬁcantly less efﬁcient than adding the

whole expression with problem.addqmatrix.

2. The row must not be an equality or a ranged row.

Related topics

problem.loadproblem, problem.getqrowcoeff, problem.addqmatrix, problem.chgqrowcoeff,

problem.getqrowqmatrix, problem.getqrowqmatrixtriplets, problem.getqrows, problem.chgqobj,

problem.chgmqobj, problem.getqobj.

Fair Isaac Corporation Conﬁdential and Proprietary Information 134

Reference Manual

problem.chgrhs

Purpose

Changes right–hand side values of the problem.

Synopsis

problem.chgrhs (mindex, rhs)

Arguments

mindex Array containing the indices of the rows whose right hand side will change.

rhs Array containing the right hand side values.

Example

Here we change the three right hand sides in rows 2, 6, and 8 to new values:

p.chgrhs ([2,8,6], [5, 3.8, 5.7])

Related topics

problem.chgcoef, problem.chgmcoef, problem.chgrhsrange, problem.getrhs,

problem.getrhsrange.

Fair Isaac Corporation Conﬁdential and Proprietary Information 135

Reference Manual

problem.chgrhsrange

Purpose

Change the range for one or more rows of the problem.

Synopsis

problem.chgrhsrange (mindex, rng)

Arguments

mindex Array containing the indices of the rows on which the range elements will change.

rng Array containing the range values.

Example

Here, the constraint cons1 x + y ≤ 10 is changed to 8 ≤ x + y ≤ 10:

p.chgrhsrange ([cons1], [2])

Further information

If the range speciﬁed on the row is r, what happens depends on the row type and value of r. It is

possible to convert non-range rows using this routine.

Value of r Row type Effect

r ≥ 0 = b, ≤ b b − r ≤

≤ b

r ≥ 0 ≥ b b ≤

≤ b + r

r < 0 = b, ≤ b b ≤

≤ b − r

r < 0 ≥ b b + r ≤

≤ b

Related topics

problem.chgcoef, problem.chgmcoef, problem.chgrhs, problem.getrhsrange.

Fair Isaac Corporation Conﬁdential and Proprietary Information 136

Reference Manual

problem.chgrowstatus

Purpose

Change the status setting of a constraint

Synopsis

problem.chgrowstatus (rowindex, status)

Arguments

rowindex The index of the matrix row to be changed.

status The bitmap with the new status settings. If the status is to be changed, always get

the current status ﬁrst (use problem.getrow) and then change settings as required.

The only settings likely to be changed are:

Bit 11 Set if row must not have a penalty error vector. This is the equivalent

of an enforced constraint (SLPDATA type EC).

Example

The following example changes the status of row 9 to be an enforced constraint.

status = p.getrowstatus (9)

status = status | (1<<11)

p.chgrowstatus (9, status)

Further information

If status is None the current status will remain unchanged.

Related topics

problem.getrowstatus

Fair Isaac Corporation Conﬁdential and Proprietary Information 137

Reference Manual

problem.chgrowtype

Purpose

Changes the type of a row in the problem.

Synopsis

problem.chgrowtype (mindex, qrtype)

Arguments

mindex Array containing the indices of the rows.

qrtype Character array giving the new row types:

L indicates a ≤ row;

E indicates an = row;

G indicates a ≥ row;

R indicates a range row;

N indicates a free row.

Example

Here two rows are changed to an equality and a free row, respectively:

p.chgrowtype ([con1, con2], [’E’, ’N’])

Further information

A row can be changed to a range type row by ﬁrst changing the row to an R or L type row and

then changing the range on the row using problem.chgrhsrange.

Related topics

problem.addrows, problem.chgcoltype, problem.chgrhs, problem.chgrhsrange,

problem.getrowtype.

Fair Isaac Corporation Conﬁdential and Proprietary Information 138

Reference Manual

problem.chgrowwt

Purpose

Set or change the initial penalty error weight for a row

Synopsis

problem.chgrowwt (rowindex, value)

Arguments

RowIndex The index of the row whose weight is to be set or changed.

Value The new value of the weight. May be None if not required.

Example

The following example sets the initial weight of row number 2 to a ﬁxed value of 3.6 and the

initial weight of row 4 to a value twice the calculated default value.

p.chgrowwt (2, -3.6)

p.chgrowwt (4,2)

Further information

A positive value is interpreted as a multiplier of the default row weight calculated by Xpress SLP.

A negative value is interpreted as a ﬁxed value: the absolute value is used directly as the row

weight.

The initial row weight is used only when the augmented structure is created. After that, the

current weighting can be accessed and changed using problem.rowinfo.

Related topics

problem.getrowwt, problem.rowinfo

Fair Isaac Corporation Conﬁdential and Proprietary Information 139

Reference Manual

problem.chgtolset

Purpose

Add or change a set of convergence tolerances used for SLP variables

Synopsis

problem.chgtolset (ntol, status, tols)

Arguments

ntol Tolerance set for which values are to be changed. A zero value for nSLPTol will

create a new set.

status Address of an integer holding a bitmap describing which tolerances are active in

this set. See below for the settings.

tols Array of 9 double precision values holding the values for the corresponding

tolerances.

Example

The following example creates a new tolerance set with the default values for all tolerances

except the relative delta tolerance, which is set to 0.005. It then changes the value of the

absolute delta and absolute impact tolerances in tolerance set 6 to 0.015

Tols = 9*[0]

Tols[2] = 0.005

Status = 1<<2;

p.chgtolset (0, 1<<2, Tols)

Tols[1] = 0.015

Tols[5] = 0.015

Status = 1<<1 | 1<<5

p.chgtolset (6, Status, Tols)

Further information

The bits in status are set to indicate that the corresponding tolerance is to be changed in the

tolerance set. The meaning of the bits is as follows: