Python API参考手册

为了方便用户对复杂应用场景进行建模并调用求解器进行求解,杉数求解器设计并提供了Python接口, 本章节将对Python接口的功能进行阐述。

COPT常数类

常数类定义了使用Python接口建模时必要的常数,包括一般常数、信息、参数和属性四大类常数。 本节将依次阐述上述四类常数的内容与使用方法。

一般常数

一般常数主要定义了建模中常用的常数,包括优化方向、变量类型和求解状态等。用户通过 COPT 前缀访问一般常数,如 COPT.VERSION_MAJOR 表示软件大版本号信息。

一般常数类中的内容,详见 一般常数章节

属性

属性类常数包括优化模型和求解结果相关属性。

在Python API中, 属性类常数中的内容,详见 属性章节

在Python API中,用户可以通过 COPT.Attr 前缀访问属性常数,如 COPT.Attr.Cols 表示模型中变量个数。

在Python API中,通过指定属性名称获取属性取值,具体请参考 Python Model类

  • Model.getAttr() ,如: Model.getAttr("Cols") 获取模型中变量个数;

信息

信息类常数包括模型信息和求解结果相关信息。

Python API信息类常数中的内容,详见 信息章节

在Python API中,用户可以通过 COPT.Info 前缀访问信息常数,如 COPT.Info.Obj 表示变量在目标函数中系数。可以通过指定信息名称获取或设置对象的信息取值:

  • 获取变量或约束信息取值: Model.getInfo() / Var.getInfo() / Constraint.getInfo()

  • 设置变量或约束信息取值: Model.setInfo() / Var.setInfo() / Constraint.setInfo()

Callback信息

Python API Callback信息常数中的内容,详见 信息章节:Callback相关信息

在Python API中,Callback相关的信息常数定义在 CbInfo 类里, 用户可以通过前缀 COPT.CbInfo. 访问Callback信息常数。

例如,COPT.CbInfo.BestObj 是当前最优目标函数值。

在Python API中,用户可以通过CallbackBase类的函数,指定信息名称来获取回调信息的值。

例如, CallbackBase.getInfo(COPT.CbInfo.BestObj) :获取当前最优目标函数值。

参数

参数类常数表示杉数求解器的优化参数,优化参数控制COPT求解器优化算法的行为。

Python API参数类常数中的内容,详见 参数章节

在Python API中,用户可通过 COPT.Param 前缀访问参数常数,如 COPT.Param.TimeLimit 表示模型的求解时间限制。

在Python API中,通过指定参数名称获取和设置参数取值。提供的函数如下,具体请参考 Python Model类

  • 获取指定参数的详细信息(当前值/最大值/最小值): Model.getParamInfo()

  • 获取指定参数当前值: Model.getParam()

  • 设置指定参数取值: Model.setParam()

优化建模类

优化建模类是杉数求解器的Python接口的主要功能类,它提供了丰富且易用的方法,便于用户快速构建复杂 的实际场景下的优化模型。本节内容中将详细阐述各方法的功能与使用方式。

EnvrConfig类

EnvrConfig类是杉数求解器的客户端配置相关操作的封装,提供了以下成员方法:

EnvrConfig()

摘要

EnvrConfig()

描述

EnvrConfig类的构造函数,该方法将创建并返回一个 EnvrConfig类 对象。

示例

# 创建杉数求解器客户端配置
envconfig = EnvrConfig()

EnvrConfig.set()

摘要

set(name, value)

描述

设置客户端配置参数。

参量

name

客户端配置参数名。可取值参考 客户端配置参数

value

客户端配置参数值。

示例

# 设置客户端配置参数
envconfig.set(COPT.CLIENT_WAITTIME, 600)
envconfig.set(COPT.CLIENT_CLUSTER, "127.0.0.1")
# 设置关闭创建COPT求解环境时输出的banner信息(如版本号等)
envconfig.set("nobanner", "1")

Envr类

Envr类是杉数求解器的求解环境相关操作的封装,提供了以下成员方法:

Envr()

摘要

Envr(arg=None)

描述

Envr类的构造函数,该方法将创建并返回一个 Envr类 对象。

参量

arg

授权文件的路径或客户端配置。可选参数,默认为 None

示例

# 创建杉数求解器求解环境
env = Envr()

Envr.createModel()

摘要

createModel(name="")

描述

创建优化模型,返回一个 Model类 对象。

参量

name

待创建优化模型的名称。可选参数,默认为 ""

示例

# 创建杉数求解器求解模型
model = env.createModel("coptprob")

Envr.close()

摘要

close()

描述

关闭与远程服务器的连接。

示例

# 关闭与远程服务器的连接
env.close()

Model类

为了方便用户访问模型的相关属性和优化参数值,Model类提供了形如 Model.Rows 的访问方式。 目前支持的属性详见 属性章节 部分,对于每个属性名,其大小写无关。

需要指出的是,对于线性或者整数规划模型,均通过 Model.objvalModel.status 获取 模型的目标函数值和求解状态。

对于优化求解参数,用户还可以通过形如 "Model.Param.TimeLimit = 10" 的方式设置优化参数。 目前支持的参数名称详见 参数 部分,

Model类是杉数求解器模型相关操作的封装,提供了以下成员方法:

Model.addVar()

摘要

addVar(lb=0.0, ub=COPT.INFINITY, obj=0.0, vtype=COPT.CONTINUOUS, name="", column=None)

描述

添加一个变量到模型中,并返回创建的一个 Var类 对象。

参量

lb

变量的下界。可选参量,默认为0.0。

ub

变量的上界。可选参量,默认为 COPT.INFINITY

obj

变量的目标函数系数。可选参量,默认为0.0。

vtype

变量类型。可选参量,默认为 COPT.CONTINUOUS ,可取值详见 变量类型

name

变量的名字。可选参量,默认为 "" ,由求解器内部自动生成。

column

变量对应的列。可选参量,默认为 None

示例

# 添加一个连续变量
x = m.addVar()
# 添加一个二进制变量
y = m.addVar(vtype=COPT.BINARY)
# 添加一个整数变量,下界为-1.0, 上界为1.0,目标函数系数为1.0,变量名为"z"
z = m.addVar(-1.0, 1.0, 1.0, COPT.INTEGER, "z")

Model.addVars()

摘要

addVars(*indices, lb=0.0, ub=COPT.INFINITY, obj=0.0, vtype=COPT.CONTINUOUS, nameprefix="C")

描述

添加一组变量到模型中,并返回一个 tupledict类 对象, 其键为变量的下标,值为相应的 Var类 对象。

参量

*indices

变量的下标。

lb

变量的下界。可选参量,默认为0.0。

ub

变量的上界。可选参量,默认为 COPT.INFINITY

obj

变量的目标函数系数。可选参量,默认为0.0。

vtype

变量的类型。可选参量,默认为 COPT.CONTINUOUS ,可取值详见 变量类型

nameprefix

变量的名称前缀。可选参量,默认为 "C",其实际名称结合变量的下标自动生成。

示例

# 添加三维整数变量x,共计6个变量
x = m.addVars(1, 2, 3, vtype=COPT.INTEGER)
# 添加2个连续变量y,其下标由tl中的元素指定,变量名前缀为"tl"
tl = tuplelist([(0, 1), (1, 2)])
y  = m.addVars(tl, nameprefix="tl")

Model.addMVar()

摘要

addMVars(shape, lb=0.0, ub=COPT.INFINITY, obj=0.0, vtype=COPT.CONTINUOUS, nameprefix="")

描述

添加 MVar类 对象到模型中。它在矩阵建模中使用,可以像NumPy里多维数组一样运算, 其形状和维度都有类似定义。

参量

shape

取值为整数,或者整数元组。表示 MVar类 对象的形状。

lb

变量的下界。可选参量,默认为0.0。

ub

变量的上界。可选参量,默认为 COPT.INFINITY

obj

变量的目标函数系数。可选参量,默认为0.0。

vtype

变量的类型。可选参量,默认为 COPT.CONTINUOUS ,可取值详见 变量类型

nameprefix

变量的名称前缀。可选参量,默认为 "",其实际名称结合变量的下标自动生成。

返回值

返回一个 MVar类 对象

示例

model.addMVar((2, 3), lb=0.0, nameprefix="mx")

Model.addConstr()

摘要

addConstr(lhs, sense=None, rhs=None, name="")

描述

添加一个线性约束到模型中,返回 Constraint类 对象;

添加一个半定约束到模型中,返回 PsdConstraint类 对象;

添加一个Indicator约束到模型中,返回 GenConstr类 对象;

添加LMI约束到模型中,返回 LmiConstraint类 对象。

若添加线性约束,则参数 lhs 可取值为 Var类 对象、 LinExpr类 对象或 ConstrBuilder类 对象; 若添加半定约束,则参数 lhs 可取值为 PsdExpr类 对象 或 PsdConstrBuilder类 对象; 若添加Indicator约束,则参数 lhsGenConstrBuilder类 对象, 并忽略其它参数; 若添加LMI约束,则参数 lhsLmiExpr类 对象。

参量

lhs

线性约束的左端项或约束构建器。

sense

线性约束的类型。可选参量,默认为 None 。 可取值详见 约束类型

rhs

线性约束的右端项。可选参量,默认为 None 。可取值为常数、 Var类 对象或 LinExpr类 对象。

name

线性约束的名称。可选参量,默认为 "",由求解器内部自动生成。

示例

# 添加一个线性等式约束:x + y == 2
m.addConstr(x + y, COPT.EQUAL, 2)
# 添加一个线性大于等于约束:x + 2*y >= 3
m.addConstr(x + 2*y >= 3.0)
# 添加一个Indicator约束
m.addConstr((x == 1) >> (2*y + 3*z <= 4))

Model.addBoundConstr()

摘要

addBoundConstr(expr, lb=-COPT.INFINITY, ub=COPT.INFINITY, name="")

描述

添加一个带上下界的线性约束到模型中,并返回添加的 Constraint类 对象。

参量

expr

线性约束的表达式。可取值为 Var类 对象或 LinExpr类 对象。

lb

线性约束的下界。可选参量,默认为 -COPT.INFINITY

ub

线性约束的上界。可选参量,默认为 COPT.INFINITY

name

线性约束的名称。可选参量,默认为 "",由求解器内部自动生成。

示例

# 添加线性双边约束:-1 <= x + y <= 1
m.addBoundConstr(x + y, -1.0, 1.0)

Model.addConstrs()

摘要

addConstrs(generator, nameprefix="R")

描述

添加一组线性约束到模型中。

若参数 generator 为整数,则返回一个 ConstrArray类 对象, 其元素为 generator 个空 Constraint类 对象,用户需要进一步 指定这些约束的具体信息;

若参数 generator 为表达式生成器,则返回一个 tupledict类 对象, 其键为线性约束的下标,值为相应的 Constraint类 对象, 每个迭代生成一个 Constraint类 对象;

若参数 generator 为矩阵表达式生成器,则返回一个 MConstr类 对象。

参量

generator

整数或(矩阵)表达式生成器。

nameprefix

线性约束的名称前缀。可选参量,默认为 "R",其实际名称结合线性约束的下标自动生成。

示例

# 添加10个线性约束,每个约束形如:x[0] + y[0] >= 2.0
m.addConstrs(x[i] + y[i] >= 2.0 for i in range(10))

Model.addMConstr()

摘要

addMConstr(A, x, sense, b, nameprefix="")

描述

通过矩阵建模的方式,添加一组线性约束到模型中。如果这里 sense 取值为 COPT.LESS_EQUAL ,添加的约束为 \(Ax <= b\)

更方便的是通过矩阵乘法生成 MLinExpr类 对象,再使用重载的比较运算符 生成 MConstrBuilder类 对象,可以作为 Model.addConstrs() 的输入 生成一组线性约束。

参量

A

参数A是一个二维的 NumPy 矩阵,或者 SciPy 列压缩矩阵( csc_matrix )或行压缩矩阵( csr_matrix )。

x

线性项对应的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象; 如果为空,但参数c不空,则取模型中所有的变量。

sense

约束的类型。可取值参考 约束类型

b

约束右边值,通常是浮点数,也可以是一组数,或者NumPy的一维数组。

nameprefix

约束名前缀。

返回值

返回一个 MConstr类 对象

示例

A = np.full((2, 3), 1)
mx = model.addMVar(3, nameprefix="mx")
mc = model.addMConstr(A, mx, 'L', 1.0, nameprefix="mc")

Model.addSOS()

摘要

addSOS(sostype, vars, weights=None)

描述

添加一个SOS约束到模型中,并返回添加的 SOS类 对象。

若参数 sostypeSOSBuilder类 对象, 则参数 vars 和参数 weights 的取值将被忽略; 若参数 sostype 为SOS约束类型,可取值为 SOS约束类型,则参数 vars 表示SOS约束的变量, 可取值为 VarArray类 对象、列表、字典或 tupledict类 对象; 若参数 weightsNone ,则SOS约束的变量权重由求解器自动生成, 否则采用用户传入的数据作为权重,可取值为列表、字典或 tupledict类 对象。

参量

sostype

SOS约束类型或SOS约束构建器。

vars

SOS约束的变量。

weights

SOS约束的变量的权重。可选取值,默认为 None

示例

# 添加一个SOS1约束,包括变量x和y,权重分别为1和2
m.addSOS(COPT.SOS_TYPE1, [x, y], [1, 2])

Model.addGenConstrIndicator()

摘要

addGenConstrIndicator(binvar, binval, lhs, sense=None, rhs=None)

描述

添加一个Indicator约束到模型中,并返回添加的 GenConstr类 对象。

若参数 lhsConstrBuilder类 对象,则参数 sense 和 参数 rhs 的取值将被忽略; 若参数 lhs 表示线性约束左端项,可取值为 Var类 对象或 LinExpr类 对象。

参量

binvar

Indicator变量。

binval

Indicator变量的取值,可取值为 TrueFalse

lhs

Indicator约束中线性约束的左端项或线性约束构建器。

sense

Indicator约束中线性约束的类型。可选参量,默认为 None 。 可取值详见 约束类型

rhs

Indicator约束中线性约束的右端项。可选参量,默认为 None 。可取值为常数。

示例

# 添加一个Indicator约束,当x为真时,线性约束 y + 2*z >= 3成立
m.addGenConstrIndicator(x, True, y + 2*z >= 3)

Model.addConeByDim()

摘要

addConeByDim(dim, ctype, vtype, nameprefix="ConeV")

描述

添加一个指定维度的二阶锥约束到模型中,并返回添加的 Cone类 对象。

参量

dim

二阶锥约束的维度。

ctype

二阶锥约束的类型。

vtype

二阶锥约束中变量的类型。

nameprefix

二阶锥约束中变量名称的前缀。可选取值,默认为 "ConeV"

示例

# 添加一个5维的旋转二阶锥
m.addConeByDim(5, COPT.CONE_RQUAD, None)

Model.addCone()

摘要

addCone(vars, ctype)

描述

添加一个指定变量构成的二阶锥约束。

若参数 varsConeBuilder类 对象,则参数 ctype 的值将被忽略; 若参数 vars 为变量,可取值为 VarArray类 对象、列表、字典 或 tupledict类 对象,参数 ctype 表示二阶锥约束的类型。

参量

vars

构成二阶锥约束的变量。

ctype

二阶锥约束的类型。

示例

# 添加由[z, x, y]构成的标准二阶锥约束
m.addCone([z, x, y], COPT.CONE_QUAD)

Model.addQConstr()

摘要

addQConstr(lhs, sense=None, rhs=None, name="")

描述

添加一个线性约束或二次约束到模型中,并返回添加的 Constraint类 对象 或 QConstraint类 对象。

若添加线性约束,则参数 lhs 可取值为 Var类 对象、 LinExpr类 对象或 ConstrBuilder类 对象; 若添加二次约束,则参数 lhsQConstrBuilder类 对象, 或者 MQConstrBuilder类 对象,并忽略其它参数。

参量

lhs

约束的左端项或约束构建器。

sense

约束的类型。可选参量,默认为 None 。 可取值详见 约束类型

rhs

约束的右端项。可选参量,默认为 None 。可取值为常数、 Var类 对象、 LinExpr类 对象或 QuadExpr类 对象 。

name

约束的名称。可选参量,默认为 "",由求解器内部自动生成。

示例

# 添加一个线性等式约束:x + y == 2
m.addQConstr(x + y, COPT.EQUAL, 2)
# 添加一个二次约束:x*x + y*y <= 3
m.addQConstr(x*x + y*y <= 3.0)

Model.addMQConstr()

摘要

addMQConstr(Q, c, sense, rhs, xQ_L=None, xQ_R=None, xc=None, name="")

描述

通过矩阵建模的方式,添加一个二次约束到模型中。如果这里sense取值为 COPT.LESS_EQUAL,添加的约束为 \(x_{Q_L} Q x_{Q_R} + c x_c <= rhs\)

更方便的是通过矩阵乘法生成 MQuadExpr类 对象,再使用重载的比较运算符 生成 MQConstrBuilder类 对象,可以作为Model.addQConstr()的输入 生成二次约束。

参量

Q

如果二次项非空,需要提供参数Q,即一个二维的 NumPy 矩阵,或者 SciPy 列压缩矩阵( csc_matrix )或行压缩矩阵( csr_matrix )。

c

如果一次项非空,需要提供参数c,即一个一维的NumPy数组,或者Python列表。

sense

约束的类型。可取值参考 约束类型

rhs

约束右边值,通常是浮点数。

xQ_L

二次项左侧的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象;

如果为空,则取模型中所有的变量。

xQ_R

二次项右侧的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象;

如果为空,则取模型中所有的变量。

xc

线性项对应的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象; 如果为空,但参数c不空,则取模型中所有的变量。

name

约束名。

返回值

返回一个 QConstraint类 对象

示例

Q = np.full((3, 3), 1)
mx = model.addMVar(3, nameprefix="mx")
mqc = model.addMQConstr(Q, None, 'L', 1.0, mx, mx, None, name="mqc")

Model.addPsdVar()

摘要

addPsdVar(dim, name="")

描述

添加一个半定变量。

参量

dim

半定变量的维度。

name

半定变量的名字。

示例

# 添加维度为3,名称为 "X" 的半定变量
m.addPsdVar(3, "X")

Model.addPsdVars()

摘要

addPsdVars(dims, nameprefix="PSDV")

描述

添加一组半定变量。

参量

dim

半定变量的维度。

nameprefix

半定变量名字的前缀。

示例

# 添加2个维度均为3的半定变量
m.addPsdVars([3, 3])

Model.addUserCut()

摘要

addUserCut(lhs, sense = None, rhs = None, name="")

描述

向模型中添加一个割平面。

参量

lhs

割平面约束的左端项。

可取值为 Var类 对象, LinExpr类 对象,或者约束构建器( ConstrBuilder类 对象)。

sense

割平面的约束类型。

可选参量,默认为 None 。可取值详见 约束类型

rhs

割平面约束的右端项。

可选参量,默认为 None 。 可取值为常数、 Var类 对象,或者 LinExpr类 对象。

name

割平面的名称。

可选参量。默认为 "",由求解器内部自动生成。

示例

model.addUserCut(x+y <= 1)
model.addUserCut(x+y == [0,1])

Model.addUserCuts()

摘要

addUserCuts(generator, nameprefix="U")

描述

向模型中批量添加多个割平面。

参量

generator

一组割平面生成器。

可取值为一组线性约束构建器 ConstrBuilderArray类 对象,或多维线性约束生成器 MConstrBuilder类 对象。

nameprefix

割平面的名称前缀。

可选参量,默认为 "U" ,其实际名称结合割平面的下标自动生成。

示例

model.addUserCuts(x[i]+y[i] <= 1 for i in range(10))

Model.addLazyConstr()

摘要

addLazyConstr(lhs, sense = None, rhs = None, name="")

描述

向模型中添加一个惰性约束。

参量

lhs

惰性约束的左端项。

可取值为 Var类 对象, LinExpr类 对象,或者约束构建器( ConstrBuilder类 对象)。

sense

惰性约束的约束类型。

可选参量,默认为 None 。可取值详见 约束类型

rhs

惰性约束的右端项。

可选参量,默认为 None 。 可取值为常数、 Var类 对象,或者 LinExpr类 对象。

name

惰性约束的名称。

可选参量。默认为 "" ,由求解器内部自动生成。

示例

model.addLazyConstr(x+y <= 1)
model.addLazyConstr(x+y == [0,1])

Model.addLazyConstrs()

摘要

addLazyConstrs(generator, nameprefix="L")

描述

向模型中批量添加多个惰性约束。

参量

generator

一组惰性约束生成器。

可取值为一组线性约束构建器 ConstrBuilderArray类 对象,或多维线性约束生成器 MConstrBuilder类 对象。

nameprefix

惰性约束的名称前缀。

可选参量,默认为 "L" ,其实际名称结合惰性约束的下标自动生成。

示例

model.addLazyConstrs(x[i]+y[i] <= 1 for i in range(10))

Model.addGenConstrMin()

摘要

addGenConstrMin(resvar, vars, constant=None, name="")

描述

添加⼀条形如 \(y=\min\{x_1, x_2, \cdots, x_n, c\}\) 的约束到模型中。

参量

resvar

等式左端项 y ,可取值为 Var 类对象。

vars

等式右端 \(\min\{\}\) 函数的变量,可取值为 list 类对象。

constant

等式右端 \(\min\{\}\) 函数中的常数项,可选参数,可取值为浮点数,默认值为 None

name

约束名称,可选参数,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrMax()

摘要

addGenConstrMax(resvar, vars, constant=None, name="")

描述

添加⼀条形如 \(y=\max\{x_1, x_2, \cdots, x_n, c\}\) 的约束到模型中。

参量

resvar

等式左端项 y ,可取值为 Var 类对象。

vars

等式右端 \(\max\{\}\) 函数的变量,可取值为 list 类对象。

constant

等式右端 \(\max\{\}\) 函数中的常数项,可选参量,可取值为浮点数,默认值为 None

name

约束名称,可选参量,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrAbs()

摘要

addGenConstrAbs(resvar, argvar, name="")

描述

添加⼀条形如 \(y=|x|\) 的约束到模型中。

参量

resvar

\(y\) ,可取值为 Var 类或 LinExpr 类对象。

argvar

\(x\) ,可取值为 Var 类对象。

name

约束名称,可选参数,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrAnd()

摘要

addGenConstrAnd(resvar, vars, name="")

描述

添加一条逻辑 and 约束,\(y = x_1 \text{ and } x_2 \cdots \text{ and } x_n\) 至模型中。

参量

resvar

等式左端项 y ,可取值为二进制型 Var 类对象。

vars

逻辑运算符 and 连接的元素 \(x_i, \text{for } i \in \{1,2,\cdots,n\}\) ,可取值为 List 类(其中元素为二进制型 Var 类对象)。

name

约束名称,可选参数,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrOr()

摘要

addGenConstrOr(resvar, vars, name="")

描述

添加一条逻辑 or 约束,\(y = x_1 \text{ or } x_2 \cdots \text{ or } x_n\) 至模型中。

参量

resvar

等式左端项 y ,可取值为二进制型 Var 类对象。

argvar

逻辑运算符 or 连接的元素 \(x_i, \text{for } i \in \{1,2,\cdots,n\}\) ,可取值为 List 类(其中元素为二进制型 Var 类对象)。

name

约束名称,可选参数,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrPWL()

摘要

addGenConstrPWL(xvar, yvar, xpts, ypts, name="")

描述

添加形如 \(y=f(x)\) 的约束,其中分段线性函数定义为:

(33)\[\begin{split}f(v) = \begin{cases} \tilde{y}_1 + \frac{\tilde{y}_2-\tilde{y}_1}{\tilde{x}_2-\tilde{x}_1} (v-\tilde{x}_1),\quad &\text{if } v\leq x_1 \\ \tilde{y}_i + \frac{\tilde{y}_{i+1} - \tilde{y}_i}{\tilde{x}_{i+1} - \tilde{x}_i} (v-\tilde{x}_i),\quad &\text{if } \tilde{x}_i\leq v\leq \tilde{x}_{i+1} \\ \tilde{y}_n + \frac{\tilde{y}_n - \tilde{y}_{n-1}}{\tilde{x}_n - \tilde{x}_{n-1}}(v-\tilde{x}_n),\quad &\text{if } v\geq \tilde{x}_n \end{cases}\notag\end{split}\]

参量

xvar

x ,可取值为 Var 类对象。

yvar

等式左端项 y ,可取值为 Var 类或 LinExpr 类对象。

xpts

\(\tilde{\boldsymbol{x}}\) ,分段点的横坐标,需按照取值从小到大的顺序排列,可取值为 List 类。

ypts

\(\tilde{\boldsymbol{y}}\) ,分段点的纵坐标,可取值为 List 类。

name

约束名称,可选参数,默认值为 ""

返回值

返回一个 GenConstrX 类对象。

Model.addSparseMat()

摘要

addSparseMat(dim, rows, cols=None, vals=None)

描述

添加稀疏矩阵表示的对称矩阵。

参量

dim

对称矩阵的维度。

rows

对称矩阵非零元素的行索引。

cols

对称矩阵非零元素的列索引。

vals

对称矩阵非零元素值。

示例

# 添加维度为3的对称矩阵
m.addSparseMat(3, [0, 1, 2], [0, 1, 2], [2.0, 5.0, 8.0])
# 添加维度为2的对称矩阵
m.addSparseMat(2, [(0, 0, 3.0), (1, 0, 1.0)])

Model.addDenseMat()

摘要

addDenseMat(dim, vals)

描述

添加致密矩阵表示的对称矩阵。

参量

dim

对称矩阵的维度。

vals

对称矩阵非零元素值。可取值为:常数、列表。

示例

# 添加维度为3的全1对称矩阵
m.addDenseMat(3, 1.0)

Model.addDiagMat()

摘要

addDiagMat(dim, vals, offset=None)

描述

添加对角对称矩阵。

参量

dim

对称矩阵的维度。

vals

对称矩阵非零元素值。可取值为:常数、列表。

offset

对角元素位置偏移量,若为正值,则对角线向上偏移;若为负值,则对角线向下偏移。

示例

# 添加维度为3的单位矩阵
m.addDiagMat(3, 1.0)

Model.addOnesMat()

摘要

addOnesMat(dim)

描述

添加全1矩阵。

参量

dim

全1矩阵的维度。

示例

# 添加维度为3的全1矩阵
m.addOnesMat(3)

Model.addEyeMat()

摘要

addEyeMat(dim)

描述

添加单位矩阵。

参量

dim

单位矩阵的维度。

示例

# 添加维度为3的单位矩阵
m.addEyeMat(3)

Model.setObjective()

摘要

setObjective(expr, sense=None)

描述

设置模型的目标函数。

参量

expr

目标函数的表达式。可取值为常数、Var类 对象、 LinExpr类 对象、 QuadExpr类 对象, 以及 MLinExpr类 对象、 MQuadExpr类 对象。

注意:该如果 exprLinExpr类 对象,则更新目标函数中的线性项; 如果是 QuadExpr类 对象,则更新目标函数中的二次项和线性项。

sense

目标函数的优化方向。可选参量,默认为 None ,表示不改动模型的优化方向。 模型的当前优化方向通过属性 ObjSense 查看。 可取值详见 优化方向

示例

# 设置目标函数为 x + y,优化方向为最大化
m.setObjective(x + y, COPT.MAXIMIZE)

Model.setMObjective()

摘要

setMObjective(Q, c, constant, xQ_L=None, xQ_R=None, xc=None, sense=None)

描述

通过矩阵建模的方式,设置模型的二次目标。可添加形如 \(x_{Q_L} Q x_{Q_R} + c x_c + constant\) 的目标函数。

更方便的是通过矩阵乘法生成 MQuadExpr类 对象,可以作为 setObjective()的输入设置目标函数。

参量

Q

如果二次项非空,需要提供参数Q,即一个二维的 NumPy 矩阵,或者 SciPy 列压缩矩阵( csc_matrix )或行压缩矩阵( csr_matrix )。

c

如果一次项非空,需要提供参数c,即一个一维的NumPy数组,或者Python列表。

constant

常数项,通常是浮点数。

xQ_L

二次项左侧的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象。 如果为空,则取模型中所有的变量。

xQ_R

二次项右侧的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象。 如果为空,则取模型中所有的变量。

xc

线性项对应的变量,可以是 MVar类 对象, VarArray类 对象、列表、字典或 tupledict类 对象。 如果为空,但参数c不空,则取模型中所有的变量。

sense

目标函数的优化方向。可选参量,默认为 None ,表示不改动模型的优化方向。 模型的当前优化方向通过属性 ObjSense 查看。 可取值详见 优化方向

示例

Q = np.full((3, 3), 1)
mx = model.addMVar(3, nameprefix="mx")
my = model.addVars(3, nameprefix="my")
mqc = model.setMObjective(Q, None, 0.0, mx, my, None, sense=COPT.MINIMIZE)

Model.setObjSense()

摘要

setObjSense(sense)

描述

设置目标函数的优化方向。

参量

sense

目标函数的优化方向。可取值详见 优化方向

示例

# 设置优化方向为最大化
m.setObjSense(COPT.MAXIMIZE)

Model.setObjConst()

摘要

setObjConst(const)

描述

设置目标函数的常数偏移量。

参量

const

目标函数常数偏移量。

示例

# 设置目标函数常数偏移为1.0
m.setObjConst(1.0)

Model.getObjective()

摘要

getObjective()

描述

获取模型的目标函数,返回一个 LinExpr类 对象。

示例

# 获取模型的目标函数表达式
obj = m.getObjective()

Model.delQuadObj()

摘要

delQuadObj()

描述

删除二次目标函数中的二次项。

示例

# 删除目标函数中的二次项
m.delQuadObj()

Model.delPsdObj()

摘要

delPsdObj()

描述

删除目标函数中的半定项。

示例

# 删除目标函数中的半定项
m.delPsdObj()

Model.getCol()

摘要

getCol(var)

描述

获取指定变量对应的列,返回一个 Column类 对象。

示例

# 获取变量x相应的列
col = m.getCol(x)

Model.getRow()

摘要

getRow(constr)

描述

获取指定线性约束对应的行,返回一个 LinExpr类 对象。

示例

# 获取线性约束conx相应的行
linexpr = m.getRow(conx)

Model.getQuadRow()

摘要

getQuadRow(qconstr)

描述

获取指定二次约束对应的行,返回一个 QuadExpr类 对象。

示例

# 获取二次约束qconx相应的行
quadexpr = m.getQuadRow(qconx)

Model.getPsdRow()

摘要

getPsdRow(constr)

描述

获取指定半定约束对应的行,返回一个 PsdExpr类 对象。

示例

# 获取半定约束psdcon相应的行
psdexpr = m.getPsdRow(psdcon)

Model.getVar()

摘要

getVar(idx)

描述

根据变量在模型中的下标获取相应的变量,返回一个 Var类 对象。

参量

idx

变量在系数矩阵中的下标。起始为 0

示例

# 获取下标为1的变量
x = m.getVar(1)

Model.getVarByName()

摘要

getVarByName(name)

描述

根据变量的名称获取相应的变量,返回一个 Var类 对象。

参量

name

变量的名称。

示例

# 获取名称为"x"的变量
x = m.getVarByName("x")

Model.getVars()

摘要

getVars()

描述

获取模型中的全部变量,返回一个 VarArray类 对象。

示例

# 获取模型中的全部变量
vars = m.getVars()

Model.getConstr()

摘要

getConstr(idx)

描述

根据线性约束在模型中的下标获取相应的线性约束,返回一个 Constraint类 对象。

参量

idx

线性约束在系数矩阵中的下标。起始为 0

示例

# 获取下标为1的线性约束
r = m.getConstr(1)

Model.getConstrByName()

摘要

getConstrByName(name)

描述

根据线性约束的名称获取相应的线性约束,返回一个 Constraint类 对象。

参量

name

线性约束的名称。

示例

# 获取名称为"r"的线性约束
r = m.getConstrByName("r")

Model.getConstrs()

摘要

getConstrs()

描述

获取模型中的全部线性约束,返回一个 ConstrArray类 对象。

示例

# 获取模型中的全部线性约束
cons = m.getConstrs()

Model.getConstrBuilders()

摘要

getConstrBuilders(constrs=None)

描述

获取当前模型中的线性约束相应的构建器。

若参数 constrsNone,则返回全部线性约束相应构建器组成的一个 ConstrBuilderArray类 对象; 若参数 constrsConstraint类 对象,则返回指定约束相应的 ConstrBuilder类 对象; 若参数 constrs 为列表或 ConstrArray类 对象,则返回指定约束相应 构建器组成的一个 ConstrBuilderArray类 对象; 若参数 constrs 为字典或 tupledict类 对象, 则返回键为指定约束的下标,值为指定约束相应的构建器组成的一个 tupledict类 对象。

参量

constrs

指定的线性约束。可选参量,默认为 None

示例

# 获取所有的线性约束构建器
conbuilders = m.getConstrBuilders()
# 获取线性约束x相应的构建器
conbuilders = m.getConstrBuilders(x)
# 获取线性约束x和y相应的构建器
conbuilders = m.getConstrBuilders([x, y])
# 获取tupledict对象xx中的线性约束相应的构建器
conbuilders = m.getConstrBuilders(xx)

Model.getSOS(sos)

摘要

getSOS(sos)

描述

根据指定的SOS约束获取相应的SOS约束构建器,返回一个 SOSBuilder类 对象。

参量

sos

指定的SOS约束。

示例

# 获取SOS约束sosx相应的构建器
sosbuilder = m.getSOS(sosx)

Model.getSOSs()

摘要

getSOSs()

描述

获取模型中的全部SOS约束,返回一个 SOSArray类 对象。

示例

# 获取模型中的全部SOS约束
soss = m.getSOSs()

Model.getSOSBuilders()

摘要

getSOSBuilders(soss=None)

描述

获取指定SOS约束相应的SOS约束构建器。

若参数 sossNone,则返回全部SOS约束相应构建器组成的一个 SOSBuilderArray类 对象; 若参数 sossSOS类 对象,则返回指定SOS约束相应的 SOSBuilder类 对象; 若参数 soss 为列表或 SOSArray类 对象,则返回指定SOS约束相应 构建器组成的一个 SOSBuilderArray类 对象。

参量

soss

指定的SOS约束。可选参量,默认为 None

示例

# 获取模型中所有SOS约束相应的构建器
soss = m.getSOSBuilders()

Model.getGenConstrIndicator()

摘要

getGenConstrIndicator(genconstr)

描述

获取指定Indicator约束相应的Indicator约束构建器,返回一个 GenConstrBuilder类 对象。

参量

genconstr

指定的Indicator约束。

示例

# 获取Indicator约束genx相应的构建器
indic = m.getGenConstrIndicator(genx)

Model.getCones()

摘要

getCones()

描述

获取模型中的全部二阶锥约束,返回一个 ConeArray类 对象。

示例

# 获取模型中的全部二阶锥约束
cones = m.getCones()

Model.getConeBuilders()

摘要

getConeBuilders(cones=None)

描述

获取指定二阶锥约束相应的二阶锥约束构建器。

若参数 conesNone,则返回全部二阶锥约束相应构建器组成的一个 ConeBuilderArray类 对象; 若参数 conesCone类 对象,则返回指定二阶锥约束相应的 ConeBuilder类 对象; 若参数 cones 为列表或 ConeArray类 对象,则返回指定二阶锥约束相应 构建器组成的一个 ConeBuilderArray类 对象。

参量

cones

指定的二阶锥约束。可选参量,默认为 None

示例

# 获取模型中所有二阶锥约束相应的构建器
cones = m.getConeBuilders()

Model.getQConstr()

摘要

getQConstr(idx)

描述

根据二次约束在模型中的下标获取相应的二次约束,返回一个 QConstraint类 对象。

参量

idx

二次约束在模型中的下标。起始为 0

示例

# 获取下标为1的二次约束
qr = m.getQConstr(1)

Model.getQConstrByName()

摘要

getQConstrByName(name)

描述

根据二次约束的名称获取相应的二次约束,返回一个 QConstraint类 对象。

参量

name

二次约束的名称。

示例

# 获取名称为"qr"的二次约束
qr = m.getQConstrByName("qr")

Model.getQConstrs()

摘要

getQConstrs()

描述

获取模型中的全部二次约束,返回一个 QConstrArray类 对象。

示例

# 获取模型中的全部二次约束
qcons = m.getQConstrs()

Model.getQConstrBuilders()

摘要

getQConstrBuilders(qconstrs=None)

描述

获取当前模型中的二次约束相应的构建器。

若参数 qconstrsNone,则返回全部二次约束相应构建器组成的一个 QConstrBuilderArray类 对象; 若参数 qconstrsQConstraint类 对象,则返回指定约束相应的 QConstrBuilder类 对象; 若参数 qconstrs 为列表或 QConstrArray类 对象,则返回指定约束相应 构建器组成的一个 QConstrBuilderArray类 对象; 若参数 qconstrs 为字典或 tupledict类 对象, 则返回键为指定约束的下标,值为指定约束相应的构建器组成的一个 tupledict类 对象。

参量

qconstrs

指定的二次约束。可选参量,默认为 None

示例

# 获取所有的二次约束构建器
qconbuilders = m.getQConstrBuilders()
# 获取二次约束qx相应的构建器
qconbuilders = m.getQConstrBuilders(qx)
# 获取二次约束x和y相应的构建器
qconbuilders = m.getQConstrBuilders([qx, qy])
# 获取tupledict对象qxx中的二次约束相应的构建器
qconbuilders = m.getQConstrBuilders(qxx)

Model.getPsdVar()

摘要

getPsdVar(idx)

描述

根据半定变量在模型中的下标获取相应的半定变量,返回一个 PsdVar类 对象。

参量

idx

半定变量在模型中的下标。起始为 0

示例

# 获取下标为1的半定变量
x = m.getPsdVar(1)

Model.getPsdVarByName()

摘要

getPsdVarByName(name)

描述

根据半定变量的名称获取相应的半定变量,返回一个 PsdVar类 对象。

参量

name

半定变量的名称。

示例

# 获取名称为"x"的半定变量
x = m.getPsdVarByName("x")

Model.getPsdVars()

摘要

getPsdVars()

描述

获取模型中的全部半定变量,返回一个 PsdVarArray类 对象。

示例

# 获取模型中的全部半定变量
vars = m.getPsdVars()

Model.getPsdConstr()

摘要

getPsdConstr(idx)

描述

根据半定约束在模型中的下标获取相应的半定约束,返回一个 PsdConstraint类 对象。

参量

idx

半定约束在模型中的下标。起始为 0

示例

# 获取下标为1的半定约束
r = m.getPsdConstr(1)

Model.getPsdConstrByName()

摘要

getPsdConstrByName(name)

描述

根据半定约束的名称获取相应的半定约束,返回一个 PsdConstraint类 对象。

参量

name

半定约束的名称。

示例

# 获取名称为"r"的半定约束
r = m.getPsdConstrByName("r")

Model.getPsdConstrs()

摘要

getPsdConstrs()

描述

获取模型中的全部半定约束,返回一个 PsdConstrArray类 对象。

示例

# 获取模型中的全部半定约束
cons = m.getPsdConstrs()

Model.getPsdConstrBuilders()

摘要

getPsdConstrBuilders(constrs=None)

描述

获取当前模型中的半定约束相应的构建器。

若参数 constrsNone,则返回全部半定约束相应构建器组成的一个 PsdConstrBuilderArray类 对象; 若参数 constrsPsdConstraint类 对象,则返回指定半定约束相应的 PsdConstrBuilder类 对象; 若参数 constrs 为列表或 PsdConstrArray类 对象,则返回指定半定约束相应 构建器组成的一个 PsdConstrBuilderArray类 对象; 若参数 constrs 为字典或 tupledict类 对象, 则返回键为指定半定约束的下标,值为指定半定约束相应的构建器组成的一个 tupledict类 对象。

参量

constrs

指定的半定约束。可选参量,默认为 None

示例

# 获取所有的半定约束构建器
conbuilders = m.getPsdConstrBuilders()
# 获取半定约束x相应的构建器
conbuilders = m.getPsdConstrBuilders(x)
# 获取半定约束x和y相应的构建器
conbuilders = m.getPsdConstrBuilders([x, y])
# 获取tupledict对象xx中的半定约束相应的构建器
conbuilders = m.getPsdConstrBuilders(xx)

Model.getLmiRow()

摘要

getLmiRow(constr)

描述

获取参与指定LMI约束的LMI表达式,包括变量和对应的系数矩阵。

参量

constr

指定的约束。

示例

# 获取LMI约束c中的表达式
expr = m.getLmiRow(c)

Model.getLmiConstr()

摘要

getLmiConstr(idx)

描述

获取模型中指定索引对应的LMI约束。

参量

idx

LMI约束在模型中的下标。起始为 0

示例

# 获取模型中第1个LMI约束
coeff = m.getLmiConstr(1)

Model.getLmiConstrByName()

摘要

getLmiConstrByName(name)

描述

获取模型中指定名称的LMI约束。

参量

name

指定的LMI约束名称。

示例

# 获取模型中名称为r1的LMI约束
name = m.getLmiConstrByName("r1")

Model.getLmiConstrs()

摘要

getLmiConstrs()

描述

获取模型中所有的LMI约束。返回LMI约束构成的 LmiConstrArray类 对象。

Model.getLmiRhs()

摘要

getLmiRhs(constr)

描述

获取指定LMI约束的常数项。返回 SymMatrix类 对象。

参量

constr

指定的LMI约束。

Model.setLmiRhs()

摘要

setLmiRhs(constr, mat)

描述

设置指定LMI约束的常数项。

参量

constr

指定的LMI约束。

mat

新的常数项矩阵。

示例

# 设置LMI约束con的常数项对称矩阵为D
m.setLmiRhs(con, D)

Model.getLmiSolution()

摘要

getLmiSolution()

描述

获取LMI约束的取值和对偶值。

Model.getLmiSlacks()

摘要

getLmiSlacks()

描述

获取LMI约束全部松弛变量的取值,返回一个列表对象。

Model.getLmiDuals()

摘要

getLmiDuals()

描述

获取LMI约束全部对偶变量的取值,返回一个列表对象。

Model.getCoeff()

摘要

getCoeff(constr, var)

描述

获取变量在线性约束、半定约束或LMI约束中的系数。

参量

constr

指定的线性约束、半定约束或LMI约束。

var

指定的变量或半定变量。

示例

# 获取变量x在约束c1中的系数
coeff1 = m.getCoeff(c1, x)
# 获取半定变量X在约束c2中的系数
coeff2 = m.getCoeff(c2, X)

Model.setCoeff()

摘要

setCoeff(constr, var, newval)

描述

设置变量在线性约束、半定约束或LMI约束中的系数。

参量

constr

指定的线性约束、半定约束或LMI约束。

var

指定的变量或半定变量。

newval

待设置的新系数或系数对称矩阵。

示例

# 设置变量x在约束c中的系数为1.0
m.setCoeff(c, x, 1.0)

Model.setCoeffs()

摘要

setCoeffs(constrs, vars, vals)

描述

批量设置变量在线性约束中的系数。

注意 变量和约束组合不能重复出现,即不能对约束constr中的变量var重复设置相同或不同的系数。

参量

constrs

指定和待设置系数相关的约束,可取值为字典、tupledict类 对象、 ConstrArray类 对象或一组 Constraint类 对象。

vars

指定和待设置系数相关的变量,可取值为字典、tupledict类 对象、 VarArray类 对象或一组 Var类 对象。

vals

待设置的新系数值。可取值为常数,或者是与 constrs 相匹配的列表或字典。

Model.getA()

摘要

getA()

描述

获取模型的系数矩阵,返回一个 scipy.sparse.csc_matrix 对象。该方法依赖 scipy 工具包。

示例

# 获取模型的系数矩阵
A = model.getA()

Model.loadMatrix()

摘要

loadMatrix(c, A, lhs, rhs, lb, ub, vtype=None)

描述

加载矩阵和向量信息构建模型。该方法依赖 scipy 工具包。

参量

c

目标函数系数。若为 None,则表示目标函数系数全为0。

A

系数矩阵。类型要求为 scipy.sparse.csc_matrix

lhs

约束的下边界。

rhs

约束的上边界。

lb

变量的下边界。若为 None,则表示下边界全为0。

ub

变量的上边界。若为 None,则表示上边界全为 COPT.INFINITY

vtype

变量类型。默认为 None,表示全部为连续变量。

示例

# 矩阵数据构建模型
m.loadMatrix(c, A, lhs, rhs, lb, ub)

Model.getLpSolution()

摘要

getLpSolution()

描述

获取线性规划模型的变量取值、松弛变量取值、对偶变量取值和变量的Reduced cost, 返回一个四元元组对象,元组中每个元素为一个列表对象。

示例

# 获取线性规划模型的解
values, slacks, duals, redcosts = m.getLpSolution()

Model.setLpSolution()

摘要

setLpSolution(values, slack, duals, redcost)

描述

设置线性规划模型的变量取值、松弛变量取值、对偶变量取值和变量的Reduced cost。

参量

values

变量取值。

slack

松弛变量取值。

duals

对偶变量取值。

redcost

变量的Reduced cost。

示例

# 设置线性规划模型的解
m.setLpSolution(values, slack, duals, redcost)

Model.getValues()

摘要

getValues()

描述

获取线性或整数规划模型的全部变量取值,返回一个列表对象。

示例

# 获取模型中所有变量的取值
values = m.getValues()

Model.getRedcosts()

摘要

getRedcosts()

描述

获取线性规划模型全部变量的Reduced cost,返回一个列表对象。

示例

# 获取模型中所有变量的Reduced cost
redcosts = m.getRedcosts()

Model.getSlacks()

摘要

getSlacks()

描述

获取线性规划全部松弛变量的取值,返回一个列表对象。

示例

# 获取模型中所有松弛变量的取值
slacks = m.getSlacks()

Model.getDuals()

摘要

getDuals()

描述

获取线性规划全部对偶变量的取值,返回一个列表对象。

示例

# 获取模型中所有对偶变量的取值
duals = m.getDuals()

Model.getVarBasis()

摘要

getVarBasis(vars=None)

描述

获取指定变量的基状态。

若参数 varsNone,则返回全部变量的基状态组成的一个列表对象; 若参数 varsVar类 对象,则返回指定变量的基状态; 若参数 vars 为列表或 VarArray类 对象, 则返回指定变量的基状态组成的一个列表对象; 若参数 vars 为字典或 tupledict类 对象, 则返回键为指定变量的下标,值为指定变量的基状态组成的一个 tupledict类 对象。

参量

vars

指定的变量。可选参量,默认为 None

示例

# 获取模型中全部变量的基状态
varbasis = m.getVarBasis()
# 获取变量x和y的基状态
varbasis = m.getVarBasis([x, y])
# 获取tupledict对象xx中的变量相应的基状态
varbasis = m.getVarBasis(xx)

Model.getConstrBasis()

摘要

getConstrBasis(constrs=None)

描述

获取线性规划中线性约束的基状态。

若参数 constrsNone,则返回全部线性约束的基状态组成的一个列表对象; 若参数 constrsConstraint类 对象,则返回指定线性约束的基状态; 若参数 constrs 为列表或 ConstrArray类 对象, 则返回指定线性约束的基状态组成的一个列表对象; 若参数 constrs 为字典或 tupledict类 对象, 则返回键为指定线性约束的下标,值为指定约束的基状态组成的一个 tupledict类 对象。

参量

constrs

指定的线性约束。可选参量,默认为 None

示例

# 获取模型中全部线性约束的基状态
conbasis = m.getConstrBasis()
# 获取模型中线性约束r0和r1相应的基状态
conbasis = m.getConstrBasis([r0, r1])
# 获取tupledict对象rr中的线性约束相应的基状态
conbasis = m.getConstrBasis(rr)

Model.getPoolObjVal()

摘要

getPoolObjVal(isol)

描述

获取解池中第 isol 个解的目标函数值,返回一个常数。

参量

isol

解池中解的索引。

示例

# 获取第2个解的目标函数值
objval = m.getPoolObjVal(2)

Model.getPoolSolution()

摘要

getPoolSolution(isol, vars)

描述

获取解池中第 isol 个解中指定变量的取值。

若参数 varsVar类 对象,则返回指定变量的取值; 若参数 vars 为列表或 VarArray类 对象, 则返回指定变量的取值组成的一个列表对象; 若参数 vars 为字典或 tupledict类 对象, 则返回键为指定变量的下标,值为指定变量的取值组成的一个 tupledict类 对象。

参量

isol

解池中解的索引。

vars

指定的变量。

示例

# 获取第2个解中变量x的值
xval = m.getPoolSolution(2, x)

Model.getVarLowerIIS()

摘要

getVarLowerIIS(vars)

描述

获取指定变量下边界的IIS状态。

若参数 varsVar类 对象,则返回指定变量下边界的IIS状态; 若参数 vars 为列表或 VarArray类 对象, 则返回指定变量下边界的IIS状态组成的一个列表对象; 若参数 vars 为字典或 tupledict类 对象, 则返回键为指定变量的下标,值为指定变量下边界的IIS状态组成的一个 tupledict类 对象。

参量

vars

指定的变量。

示例

# 获取变量x和y的下边界的IIS状态
lowerIIS = m.getVarLowerIIS([x, y])
# 获取tupledict对象xx中的变量下边界相应的IIS状态
lowerIIS = m.getVarLowerIIS(xx)

Model.getVarUpperIIS()

摘要

getVarUpperIIS(vars)

描述

获取指定变量上边界的IIS状态。

若参数 varsVar类 对象,则返回指定变量上边界的IIS状态; 若参数 vars 为列表或 VarArray类 对象, 则返回指定变量上边界的IIS状态组成的一个列表对象; 若参数 vars 为字典或 tupledict类 对象, 则返回键为指定变量的下标,值为指定变量上边界的IIS状态组成的一个 tupledict类 对象。

参量

vars

指定的变量。

示例

# 获取变量x和y的上边界的IIS状态
upperIIS = m.getVarUpperIIS([x, y])
# 获取tupledict对象xx中的变量上边界相应的IIS状态
upperIIS = m.getVarUpperIIS(xx)

Model.getConstrLowerIIS()

摘要

getConstrLowerIIS(constrs)

描述

获取指定约束下边界的IIS状态。

若参数 constrsConstraint类 对象,则返回指定约束下边界的IIS状态; 若参数 constrs 为列表或 ConstrArray类 对象, 则返回指定约束下边界的IIS状态组成的一个列表对象; 若参数 constrs 为字典或 tupledict类 对象, 则返回键为指定约束的下标,值为指定约束下边界的IIS状态组成的一个 tupledict类 对象。

参量

constrs

指定的约束。

示例

# 获取模型中约束r0和r1相应下边界的IIS状态
lowerIIS = m.getConstrLowerIIS([r0, r1])
# 获取tupledict对象rr中的约束下边界相应的IIS状态
lowerIIS = m.getConstrLowerIIS(rr)

Model.getConstrUpperIIS()

摘要

getConstrUpperIIS(constrs)

描述

获取指定约束上边界的IIS状态。

若参数 constrsConstraint类 对象,则返回指定约束上边界的IIS状态; 若参数 constrs 为列表或 ConstrArray类 对象, 则返回指定约束上边界的IIS状态组成的一个列表对象; 若参数 constrs 为字典或 tupledict类 对象, 则返回键为指定约束的下标,值为指定约束上边界的IIS状态组成的一个 tupledict类 对象。

参量

constrs

指定的约束。

示例

# 获取模型中约束r0和r1相应上边界的IIS状态
upperIIS = m.getConstrUpperIIS([r0, r1])
# 获取tupledict对象rr中的约束上边界相应的IIS状态
upperIIS = m.getConstrUpperIIS(rr)

Model.getSOSIIS()

摘要

getSOSIIS(soss)

描述

获取指定SOS约束的IIS状态。

若参数 sossSOS类 对象,则返回指定SOS约束的IIS状态; 若参数 soss 为列表或 SOSArray类 对象, 则返回指定SOS约束的IIS状态组成的一个列表对象; 若参数 soss 为字典或 tupledict类 对象, 则返回键为指定SOS约束的下标,值为指定SOS约束的IIS状态组成的一个 tupledict类 对象。

参量

soss

指定的SOS约束。

示例

# 获取模型中SOS约束r0和r1相应的IIS状态
sosIIS = m.getSOSIIS([r0, r1])
# 获取tupledict对象rr中的SOS约束相应的IIS状态
sosIIS = m.getSOSIIS(rr)

Model.getIndicatorIIS()

摘要

getIndicatorIIS(genconstrs)

描述

获取指定Indicator约束的IIS状态。

若参数 genconstrsGenConstr类 对象,则返回指定Indicator约束的IIS状态; 若参数 genconstrs 为列表或 GenConstrArray类 对象, 则返回指定Indicator约束的IIS状态组成的一个列表对象; 若参数 genconstrs 为字典或 tupledict类 对象, 则返回键为指定Indicator约束的下标,值为指定Indicator约束的IIS状态组成的一个 tupledict类 对象。

参量

genconstrs

指定的Indicator约束。

示例

# 获取模型中Indicator约束r0和r1相应的IIS状态
indicatorIIS = m.getIndicatorIIS([r0, r1])
# 获取tupledict对象rr中的Indicator约束相应的IIS状态
indicatorIIS = m.getIndicatorIIS(rr)

Model.getAttr()

摘要

getAttr(attrname)

描述

获取指定的模型属性值,返回一个常数。

参量

attrname

指定的属性名。可取值详见 属性章节 部分。

示例

# 获取目标函数的常数项
objconst = m.getAttr(COPT.Attr.ObjConst)

Model.getInfo()

摘要

getInfo(infoname, args)

描述

获取指定的信息值。

若参数 argsVar类 对象或 Constraint类 对象, 则返回指定变量或约束的信息值常数; 若参数 args 为列表、VarArray类 对象或 ConstrArray类 对象, 则返回指定变量或约束的信息值组成的一个列表对象; 若参数 args 为字典或 tupledict类 对象, 则返回键为指定变量或约束的下标,值为指定变量或约束的信息值组成的一个 tupledict类 对象; 若参数 argsMVar类 对象或 MConstr类 对象, 则返回指定变量或约束的信息值组成的一个 numpy.ndarray 对象。

参量

infoname

待获取信息名。可取值详见 信息 部分。

args

待获取信息的变量或者约束。

示例

# 获取模型中全部线性约束的下界信息
lb = m.getInfo(COPT.Info.LB, m.getConstrs())
# 获取变量x和y的取值信息
sol = m.getInfo(COPT.Info.Value, [x, y])
# 获取tupledict对象shipconstr中的线性约束相应的对偶变量取值信息
dual = m.getInfo(COPT.Info.Dual, shipconstr)

Model.getVarType()

摘要

getVarType(vars)

描述

获取指定变量的类型。

若参数 varsVar类 对象,则返回指定变量的类型; 若参数 vars 为列表或 VarArray类 对象, 则返回指定变量的类型组成的一个列表对象; 若参数 vars 为字典或 tupledict类 对象, 则返回键为指定变量的下标,值为指定变量的类型组成的一个 tupledict类 对象。

参量

vars

指定的变量。

示例

# 获取变量x的类型
xtype = m.getVarType(x)
# 获取变量x、y和z的类型
xtype = m.getVarType([x, y, z])
# 获取tupledict对象xdict中的变量的类型
xtype = m.getVarType(xdict)

Model.getParam()

摘要

getParam(paramname)

描述

获取指定的优化参数的当前值,返回一个常数。

参量

paramname

指定的优化参数名。可取值详见 参数 部分。

示例

# 获取优化求解时间限制的当前值
timelimit = m.getParam(COPT.Param.TimeLimit)

Model.getParamInfo()

摘要

getParamInfo(paramname)

描述

获取指定的优化参数的信息,返回一个元组对象,其元素分别为:参数名、当前值、默认值、最小值和最大值。

参量

paramname

指定的优化参数名。可取值详见 参数 部分。

示例

# 获取优化求解时间限制参数的信息
pname, pcur, pdef, pmin, pmax = m.getParamInfo(COPT.Param.TimeLimit)

Model.setBasis()

摘要

setBasis(varbasis, constrbasis)

描述

设置线性规划中全部变量和线性约束的基状态。 参数 varbasisconstrbasis 为列表对象,其元素数目分别为模型中的变量总数 和线性约束总数。

参量

varbasis

变量的基状态。

constrbasis

线性约束的基状态。

示例

# 设置模型中全部变量和线性约束的基状态
m.setBasis(varbasis, constrbasis)

Model.setSlackBasis()

摘要

setSlackBasis()

描述

设置线性规划的基为松弛基。

示例

# 设置基状态为松弛基
m.setSlackBasis()

Model.setVarType()

摘要

setVarType(vars, vartypes)

描述

设置指定变量的类型。

若参数 varsVar类 对象, 则参数 vartypes变量类型 常量; 若参数 vars 为字典或 tupledict类 对象, 则参数 vartypes 可为 变量类型 常量、字典或 tupledict类 对象; 若参数 vars 为列表或 VarArray类 对象, 则参数 vartypes 可为 变量类型 常量或列表对象。

参量

vars

指定的变量。

vartypes

指定的变量类型。

示例

# 设置变量x为整数变量
m.setVarType(x, COPT.INTEGER)
# 设置变量x和y为二进制变量
m.setVarType([x, y], COPT.BINARY)
# 设置tupledict对象xdict中的变量为连续变量
m.setVarType(xdict, COPT.CONTINUOUS)

Model.setNames()

摘要

setNames(args, names)

描述

设置指定变量或约束的名称。

参量

args

指定的变量或约束,可取值为单个或一组: Var类Constraint类QConstraint类PsdVar类PsdConstraint类LmiConstraint类 构成的列表或者字典对象。

names

指定的变量或约束名称。可以是单个字符串,或者是与 args 匹配的列表或字典对象。

示例

# 设置变量x为的名称为"var"
m.setNames(x, "var")
# 设置约束constr1的名称为"c1", constr2的名称为"c2"
m.setNames([constr1, constr2], ["c1", "c2"])

Model.setMipStart()

摘要

setMipStart(vars, startvals)

描述

设置指定变量的初始值,仅对整数规划模型有效。

若参数 varsVar类 对象,则参数 startvals 为常量; 若参数 vars 为字典或 tupledict类 对象, 则参数 startvals 可为常量、字典或 tupledict类 对象; 若参数 vars 为列表或 VarArray类 对象, 则参数 startvals 可为常量或列表对象。

注意: 可以通过多次调用该方法来输入不同的初始解。 请务必在输入结束后,调用 loadMipStart()

参量

vars

指定的变量。

startvals

指定的变量初始值。

示例

# 设置变量x的初始解为1
m.setMipStart(x, 1)
# 设置变量x和y的初始解分别为2和3
m.setMipStart([x, y], [2, 3])
# 设置tupledict对象xdict中的变量的初始解均为1
m.setMipStart(xdict, 1)

# 加载初始解信息到模型
m.loadMipStart()

Model.loadMipStart()

摘要

loadMipStart()

描述

将当前已指定的初始值作为一组初始值设置加载到模型中。

注意: 调用该方法后,将清空之前指定的初始值信息,用户可以继续指定新的初始解。

Model.setInfo()

摘要

setInfo(infoname, args, newvals)

描述

设置指定变量或线性约束的信息值。

若参数 argsVar类 对象或 Constraint类 对象, 则参数 newvals 为常量; 若参数 args 为字典或 tupledict类 对象, 则参数 newvals 可为常量、字典或 tupledict类 对象; 若参数 args 为列表 VarArray类 对象或 ConstrArray类 对象, 则参数 newvals 可为常量或列表对象; 若参数 args 为列表 MVar类 对象或 MConstr类 对象, 则参数 newvals 可为常量或 numpy.ndarray 对象。

参量

infoname

指定信息名。可取值详见 信息 部分。

args

指定的变量或线性约束。

newvals

指定的新信息值。

示例

# 设置变量x的上界为1.0
m.setInfo(COPT.Info.UB, x, 1.0)
# 设置变量x和y的下界分别为1.0和2.0
m.setInfo(COPT.Info.LB, [x, y], [1.0, 2.0])
# 设置tupledict对象xdict中的变量的目标函数系数均为0
m.setInfo(COPT.Info.OBJ, xdict, 0.0)

Model.setParam()

摘要

setParam(paramname, newval)

描述

设置优化参数为指定值。

参量

paramname

指定的优化参数。可取值详见 参数 部分。

newval

指定的优化参数新值。

示例

# 设置优化参数求解时间限制为1小时
m.setParam(COPT.Param.TimeLimit, 3600)

Model.resetParam()

摘要

resetParam()

描述

将模型所有优化参数重置为默认值。

示例

# 重置模型所有优化参数为默认值
m.resetParam()

Model.read()

摘要

read(filename)

描述

根据文件名后缀判断文件类型并读入到模型中。

目前支持MPS格式模型文件(后缀为 '.mps''.mps.gz')、 LP格式模型文件(后缀为 '.lp''.lp.gz')、 SDPA格式模型文件(后缀为 '.dat-s''.dat-s.gz')、 CBF格式模型文件(后缀为 '.cbf''.cbf.gz')、 COPT二进制格式文件(后缀为 '.bin')、 基解文件(后缀为 '.bas')、结果文件(后缀为 '.sol')、 初始解文件(后缀为 '.mst') 和参数文件(后缀为 '.par')。

参量

filename

待读取文件的名称。

示例

# 读取MPS格式模型文件
m.read('test.mps.gz')
# 读取LP格式模型文件
m.read('test.lp.gz')
# 读取COPT二进制格式模型文件
m.read('test.bin')
# 读取基解文件
m.read('testlp.bas')
# 读取结果文件
m.read('testmip.sol')
# 读取初始解文件
m.read('testmip.mst')
# 读取参数设置文件
m.read('test.par')

Model.readMps()

摘要

readMps(filename)

描述

按照MPS文件格式读取指定的文件到模型中。

参量

filename

待读取文件名。

示例

# 按照MPS文件格式读取文件"test.mps.gz"
m.readMps('test.mps.gz')
# 按照MPS文件格式读取文件"test.lp.gz"
m.readMps('test.lp.gz')

Model.readLp()

摘要

readLp(filename)

描述

按照LP文件格式读取指定的文件到模型中。

参量

filename

待读取文件名。

示例

# 按照LP文件格式读取文件"test.mps.gz"
m.readLp('test.mps.gz')
# 按照LP文件格式读取文件"test.lp.gz"
m.readLp('test.lp.gz')

Model.readSdpa()

摘要

readSdpa(filename)

描述

按照SDPA文件格式读取指定的文件到模型中。

参量

filename

待读取文件名。

示例

# 按照SDPA文件格式读取文件"test.dat-s"
m.readSdpa('test.dat-s')

Model.readCbf()

摘要

readCbf(filename)

描述

按照CBF文件格式读取指定的文件到模型中。

参量

filename

待读取文件名。

示例

# 按照CBF文件格式读取文件"test.cbf"
m.readCbf('test.cbf')

Model.readBin()

摘要

readBin(filename)

描述

按照COPT二进制文件格式读取指定的文件到模型中。

参量

filename

待读取文件名。

示例

# 按照COPT二进制文件格式读取文件"test.bin"
m.readBin('test.bin')

Model.readSol()

摘要

readSol(filename)

描述

按照结果文件格式读取文件到模型中。

注意: 若读取成功,则读取的值将作为整数规划模型求解的一组初始解。文件中 变量的取值可不完全指定(默认值为0),若某变量的取值指定了多次,则采用最后一次指定的值。

参量

filename

待读取文件名。

示例

# 按照结果文件格式读取文件"testmip.sol"
m.readSol('testmip.sol')
# 按照结果文件格式读取文件"testmip.txt"
m.readSol('testmip.txt')

Model.readBasis()

摘要

readBasis(filename)

描述

按照基解文件格式读取变量和线性约束的基状态到模型中,仅适用于线性规划模型。

参量

filename

待读取文件名。

示例

# 按照基解文件格式读取文件"testmip.bas"
m.readBasis('testmip.bas')
# 按照基解文件格式读取文件"testmip.txt"
m.readBasis('testmip.txt')

Model.readMst()

摘要

readMst(filename)

描述

按照初始解文件格式读取初始解到模型中。

注意: 若读取成功,则读取的值将作为整数规划模型求解的一组初始解。文件中 变量的取值可不完全指定,若某变量的取值指定了多次,则采用最后一次指定的值。

参量

filename

待读取文件名。

示例

# 按照初始解文件格式读取文件"testmip.mst"
m.readMst('testmip.mst')
# 按照初始解文件格式读取文件"testmip.txt"
m.readMst('testmip.txt')

Model.readParam()

摘要

readParam(filename)

描述

按照参数文件格式读取优化参数到模型中。

注意: 若某优化参数的取值指定了多次,则采用最后一次指定的值。

参量

filename

待读取文件名。

示例

# 按照参数文件格式读取文件"testmip.par"
m.readParam('testmip.par')
# 按照参数文件格式读取文件"testmip.txt"
m.readParam('testmip.txt')

Model.readTune()

摘要

readTune(filename)

描述

按照调优文件格式读取调优参数组合到模型中。

参量

filename

待读取文件名。

示例

# 按照调优文件格式读取文件"testmip.tune"
m.readTune('testmip.tune')
# 按照调优文件格式读取文件"testmip.txt"
m.readTune('testmip.txt')

Model.write()

摘要

write(filename)

描述

根据文件后缀名判断文件类型并写出到磁盘。

目前支持MPS格式模型文件(后缀为 '.mps')、LP格式模型文件(后缀为 '.lp')、 CBF格式模型文件(后缀为 '.cbf')、 COPT二进制格式文件(后缀为 '.bin')、基解文件(后缀为 '.bas')、 结果文件(后缀为 '.sol')、初始解文件(后缀为 '.mst')和参数文件(后缀为 '.par')。

参量

filename

待输出文件名。

示例

# 输出MPS格式模型文件
m.write('test.mps')
# 输出LP格式模型文件
m.write('test.lp')
# 输出COPT二进制格式模型文件
m.write('test.bin')
# 输出基解文件
m.write('testlp.bas')
# 输出结果文件
m.write('testmip.sol')
# 输出初始解文件
m.write('testmip.mst')
# 输出参数文件
m.write('test.par')

Model.writeMps()

摘要

writeMps(filename)

描述

将当前模型输出到MPS格式模型文件中。

参量

filename

待输出MPS格式模型文件名。

示例

# 输出MPS格式模型文件"test.mps"
m.writeMps('test.mps')

Model.writeMpsStr()

摘要

writeMpsStr()

描述

将当前模型以MPS格式输出到缓存对象。

示例

# 将当前模型以MPS格式输出到缓存对象buff中并打印模型内容
buff = m.writeMpsStr()
print(buff.getData())

Model.writeLp()

摘要

writeLp(filename)

描述

将当前模型输出到LP格式模型文件中。

参量

filename

待输出LP格式模型文件名。

示例

# 输出LP格式模型文件"test.lp"
m.writeLp('test.lp')

Model.writeCbf()

摘要

writeCbf(filename)

描述

将当前模型输出到CBF格式模型文件中。

参量

filename

待输出CBF格式模型文件名。

示例

# 输出CBF格式模型文件"test.cbf"
m.writeCbf('test.cbf')

Model.writeBin()

摘要

writeBin(filename)

描述

将当前模型输出到COPT二进制格式模型文件中。

参量

filename

待输出COPT二进制格式模型文件名。

示例

# 输出COPT二进制格式模型文件"test.bin"
m.writeBin('test.bin')

Model.writeIIS()

摘要

writeIIS(filename)

描述

将当前最小冲突模型写入IIS格式模型文件中。

参量

filename

待输出IIS格式模型文件名。

示例

# 输出IIS格式模型文件"test.iis"
m.writeIIS('test.iis')

Model.writeRelax()

摘要

writeRelax(filename)

描述

将可行化松弛模型输出到Relax格式模型文件中。

参量

filename

待输出Relax格式模型文件名。

示例

# 输出Relax格式模型文件"test.relax"
m.writeRelax('test.relax')

Model.writeSol()

摘要

writeSol(filename)

描述

将模型的结果输出到结果文件中。

参量

filename

待输出结果文件名。

示例

# 输出结果文件"test.sol"
m.writeSol('test.sol')

Model.writePoolSol()

摘要

writePoolSol(isol, filename)

描述

将指定的解池中的解写到文件中。

参量

isol

解池中解的索引。

filename

待输出结果文件名。

示例

# 输出解池中第1组解到结果文件"poolsol_1.sol"
m.writePoolSol(1, 'poolsol_1.sol')

Model.writeBasis()

摘要

writeBasis(filename)

描述

将线性规划模型的基解输出到基解文件中。

参量

filename

待输出基解文件名。

示例

# 输出基解文件"testlp.bas"
m.writeBasis('testlp.bas')

Model.writeMst()

摘要

writeMst(filename)

描述

对于整数规划模型,输出当前最好整数解到初始解文件中。若没有整数解,则输出模型中 存储的第一组初始解。

参量

filename

待输出初始解文件名。

示例

# 输出初始解文件"testmip.mst"
m.writeMst('testmip.mst')

Model.writeParam()

摘要

writeParam(filename)

描述

输出与默认参数值不相同的参数到参数文件中。

参量

filename

待输出参数文件名。

示例

# 输出参数文件"testmip.par"
m.writeParam('testmip.par')

Model.writeTuneParam()

摘要

writeTuneParam(idx, filename)

描述

输出指定编号的参数调优结果到参数文件中。

参量

idx

参数调优结果编号。

filename

待输出参数文件名。

示例

# 输出指定编号的参数调优结果到参数文件"testmip.par"
m.writeTuneParam(0, 'testmip.par')

Model.setLogFile()

摘要

setLogFile(logfile)

描述

设置求解器日志文件。

参量

logfile

日志文件。

示例

# 设置日志文件为"copt.log"
m.setLogFile('copt.log')

Model.setLogCallback()

摘要

setLogCallback(logcb)

描述

设置求解日志回调函数。

参量

logcb

求解日志回调函数。

示例

# 设置日志回调函数为Python函数'logcbfun'
m.setLogCallback(logcbfun)

Model.solve()

摘要

solve()

描述

求解优化模型。

示例

# 求解优化模型
m.solve()

Model.solveLP()

摘要

solveLP()

描述

求解线性规划模型。若是整数规划模型,则当作线性规划模型求解。

示例

# 调用线性规划求解器求解模型
m.solveLP()

Model.computeIIS()

摘要

computeIIS()

描述

计算不可行模型的IIS。

示例

# 计算不可行模型的IIS
m.computeIIS()

Model.feasRelax()

摘要

feasRelax(vars, lbpen, ubpen, constrs, rhspen, uppen=None)

描述

计算不可行模型的可行化松弛。

参量

vars

待松弛变量。

lbpen

变量下界的惩罚因子。若为 None,则表示不松弛下界; 若惩罚因子为 COPT.INFINITY,则表示不松弛相应的变量下界。

ubpen

变量上界的惩罚因子。若为 None,则表示不松弛上界; 若惩罚因子为 COPT.INFINITY,则表示不松弛相应的变量上界。

constrs

待松弛约束。

rhspen

约束边界的惩罚因子。若为 None,则表示不松弛约束边界; 若惩罚因子为 COPT.INFINITY,则表示不松弛相应的约束边界。

uppen

若约束存在双边约束,则表示约束上界的惩罚因子。若为 None, 则惩罚因子由 rhspen 指定; 若惩罚因子为 COPT.INFINITY,则表示不松弛相应的约束上界。

示例

# 计算不可行模型的可行化松弛
m.feasRelax(vars, lbpen, ubpen, constrs, rhspen)

Model.feasRelaxS()

摘要

feasRelaxS(vrelax, crelax)

描述

计算不可行模型的可行化松弛。

参量

vrelax

是否松弛变量。

crelax

是否松弛约束。

示例

# 计算不可行模型的可行化松弛
m.feasRelaxS(True, True)

Model.tune()

摘要

tune()

描述

对模型进行参数调优。

示例

# 对模型进行参数调优
m.tune()

Model.loadTuneParam()

摘要

loadTuneParam(idx)

描述

加载指定编号的参数调优结果到模型。

示例

# 加载最佳参数调优结果到模型中
m.loadTuneParam(0)

Model.interrupt()

摘要

interrupt()

描述

中断当前求解的模型。

示例

# 中断当前求解的模型
m.interrupt()

Model.remove()

摘要

remove(args)

描述

从模型中移除变量或约束。

若移除变量,则参数 args 可取值为 Var类 对象、VarArray类 对象、 列表、字典或 tupledict类 对象;

若移除线性约束,则参数 args 可取值为 Constraint类 对象、ConstrArray类 对象、 列表、字典或 tupledict类 对象;

若移除SOS约束,则参数 args 可取值为 SOS类 对象、SOSArray类 对象、 列表、字典或 tupledict类 对象;

若移除二阶锥约束,则参数 args 可取值为 Cone类 对象、ConeArray类 对象、 列表、字典或 tupledict类 对象;

若移除二次约束,则参数 args 可取值为 QConstraint类 对象、QConstrArray类 对象、 列表、字典或 tupledict类 对象;

若移除半定约束,则参数 args 可取值为 PsdConstraint类 对象、PsdConstrArray类 对象、 列表、字典或 tupledict类 对象;

若移除Indicator约束,则参数 args 可取值为 GenConstr类 对象、GenConstrArray类 对象、 列表、字典或 tupledict类 对象;

若移除LMI约束,则参数 args 可取值为 LmiConstraint类 对象、LmiConstrArray类 对象、 列表、字典或 tupledict类 对象;

若移除矩阵变量或矩阵约束,则参数 args 可取值为 MVar类 对象、MConstr类 对象。

参量

args

待移除变量或约束。

示例

# 移除线性约束conx
m.remove(conx)
# 移除变量x和y
m.remove([x, y])

Model.reset()

摘要

reset()

描述

重置模型求解结果信息。

示例

# 重置模型求解结果信息
m.reset()

Model.resetAll()

摘要

resetAll()

描述

重置模型的求解结果以及其他额外信息,如初始解、IIS等。

执行该函数后,模型需要计算的信息都会被清空,只剩下原始模型本身(即变量、目标和约束被保留)。

示例

# 重置模型的求解结果及其他额外信息
m.resetAll()

Model.clear()

摘要

clear()

描述

清空整个模型。

执行该函数后,模型中的全部内容都会被清空,包括此前添加的变量、目标和约束。

示例

# 清空整个模型
m.clear()

Model.clone()

摘要

clone()

描述

创建模型的深拷贝,返回一个 Model类 对象。

示例

# 创建模型的深拷贝
mcopy = m.clone()

Model.setCallback()

Synopsis

setCallback(cb, cbctx)

Description

在COPT模型中,设置用户自定义的回调。

Arguments

cb

用户自定义的回调类对象,继承 CallbackBase 类

cbctx

回调的触发条件,可取值详见 Callback context

Example

cb = CoptCallback()
model.setCallback(cb, COPT.CBCONTEXT_MIPSOL)

Var类

为了方便用户访问变量的相关信息,Var类提供了形如 Var.LB 的访问方式。 目前支持的信息详见 信息 部分。对于每个信息名,大小写无关。

此外,还可以通过 Var.x 访问变量的取值,通过 Var.vtype 访问变量类型, 通过 Var.name 访问变量的名称,通过 Var.rc 访问线性规划中变量的Reduced cost值, 通过 Var.basis 访问变量的基状态信息,以及通过 Var.index 访问变量在系数矩阵中的下标。

对于变量的模型相关信息,以及变量类型和名称,用户还可以通过形如 "Var.LB = 0.0" 的方式 设置相应的信息值。

Var类是杉数求解器变量的相关操作的封装,提供了以下成员方法:

Var.getType()

摘要

getType()

描述

获取变量的类型。

示例

# 获取变量v的类型
vtype = v.getType()

Var.getName()

摘要

getName()

描述

获取变量的名字。

示例

# 获取变量v的名字
varname = v.getName()

Var.getBasis()

摘要

getBasis()

描述

获取变量的基状态。

示例

# 获取变量v的基状态
varbasis = v.getBasis()

Var.getLowerIIS()

摘要

getLowerIIS()

描述

获取变量下边界的IIS状态。

示例

# 获取变量v下边界的IIS状态
lowerIIS = v.getLowerIIS()

Var.getUpperIIS()

摘要

getUpperIIS()

描述

获取变量上边界的IIS状态。

示例

# 获取变量v上边界的IIS状态
upperIIS = v.getUpperIIS()

Var.getIdx()

摘要

getIdx()

描述

获取变量在系数矩阵中的下标。

示例

# 获取变量v的下标
vindex = v.getIdx()

Var.setType()

摘要

setType(newtype)

描述

设置变量的类型。

参量

newtype

变量的新类型。可取值详见 变量类型 部分。

示例

# 设置变量v的类型
v.setType(COPT.BINARY)

Var.setName()

摘要

setName(newname)

描述

设置变量的名称。

参量

newname

变量的新名称。

示例

# 设置变量v的名称
v.setName('v')

Var.getInfo()

摘要

getInfo(infoname)

描述

获取变量指定的信息值,返回一个常数。

参量

infoname

待获取信息名。可取值详见 信息 部分。

示例

# 获取变量x的下界
lb = x.getInfo(COPT.Info.LB)

Var.setInfo()

摘要

setInfo(infoname, newval)

描述

给变量设置新的信息值。

参量

infoname

待设置信息名。可取值详见 信息 部分。

newval

待设置新信息值。

示例

# 设置变量x的下界
x.setInfo(COPT.Info.LB, 1.0)

Var.remove()

摘要

remove()

描述

从模型中删除当前变量。

示例

# 删除变量x
x.remove()

VarArray类

为方便用户对一组 Var类 对象进行操作,杉数求解器的Python接口设计了VarArray类, 提供了以下成员方法:

VarArray()

摘要

VarArray(vars=None)

描述

创建一个 VarArray类 对象。

若参数 varsNone,则创建一个空的 VarArray类 对象, 否则以参数 vars 初始化新创建的 VarArray类 对象。

参量

vars

待添加变量。可选参量,默认为 None。可取值为 Var类 对象、 VarArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的VarArray类对象
vararr = VarArray()
# 创建一个VarArray类对象,并使用变量x和y初始化
vararr = VarArray([x, y])

VarArray.pushBack()

摘要

pushBack(var)

描述

添加单个或多个 Var类 对象。

参量

var

待添加变量。可取值为 Var类 对象、VarArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加变量x到vararr中
vararr.pushBack(x)
# 添加变量x和y到vararr中
vararr.pushBack([x, y])

VarArray.getVar()

摘要

getVar(idx)

描述

根据变量在 VarArray类 对象中的下标获取相应的变量,返回一个 Var类 对象。

参量

idx

变量在 VarArray类 对象中的下标。起始为0。

示例

# 获取vararr中下标为1的变量
var = vararr.getVar(1)

VarArray.getAll()

摘要

getAll()

描述

获取 VarArray类 对象中的的全部变量,返回一个列表对象。

示例

# 获取vararr中的全部变量
varall = vararr.getAll()

VarArray.getSize()

摘要

getSize()

描述

获取 VarArray类 对象中元素的个数。

示例

# 获取vararr中变量的个数
arrsize = vararr.getSize()

PsdVar类

PsdVar类是杉数求解器半定变量的相关操作的封装,提供了以下成员方法:

PsdVar.getName()

摘要

getName()

描述

获取半定变量的名字。

示例

# 获取半定变量v的名字
varname = v.getName()

PsdVar.getIdx()

摘要

getIdx()

描述

获取半定变量在模型中的下标。

示例

# 获取半定变量v的下标
vindex = v.getIdx()

PsdVar.getDim()

摘要

getDim()

描述

获取半定变量的维度。

示例

# 获取半定变量v的维度
vdim = v.getDim()

PsdVar.getLen()

摘要

getLen()

描述

获取半定变量展开后的长度。

示例

# 获取半定变量v展开后的长度
vlen = v.getLen()

PsdVar.setName()

摘要

setName(newname)

描述

设置半定变量的名称。

参量

newname

半定变量的新名称。

示例

# 设置半定变量v的名称
v.setName('v')

PsdVar.getInfo()

摘要

getInfo(infoname)

描述

获取半定变量指定的信息值,返回一个列表。

参量

infoname

待获取信息名。可取值详见 信息 部分。

示例

# 获取半定变量x的取值
sol = x.getInfo(COPT.Info.Value)

PsdVar.remove()

摘要

remove()

描述

从模型中删除当前半定变量。

示例

# 删除半定变量x
x.remove()

PsdVar.shape

摘要

shape

描述

PsdVar 对象的形状。

返回值

整型元组。

PsdVar.size

摘要

size

描述

PsdVar 对象的形状。

返回值

整型元组。

PsdVar.dim

摘要

dim

描述

PsdVar 对象的维度。

返回值

整型值。

PsdVar.len

摘要

len

描述

PsdVar 对象展开后的长度。

返回值

整型值。

PsdVarArray类

为方便用户对一组 PsdVar类 对象进行操作,杉数求解器的Python接口设计了PsdVarArray类, 提供了以下成员方法:

PsdVarArray()

摘要

PsdVarArray(vars=None)

描述

创建一个 PsdVarArray类 对象。

若参数 varsNone,则创建一个空的 PsdVarArray类 对象, 否则以参数 vars 初始化新创建的 PsdVarArray类 对象。

参量

vars

待添加半定变量。可选参量,默认为 None。可取值为 PsdVar类 对象、 PsdVarArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的PsdVarArray类对象
vararr = PsdVarArray()
# 创建一个PsdVarArray类对象,并使用半定变量x和y初始化
vararr = PsdVarArray([x, y])

PsdVarArray.pushBack()

摘要

pushBack(var)

描述

添加单个或多个 PsdVar类 对象。

参量

var

待添加半定变量。可取值为 PsdVar类 对象、PsdVarArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加半定变量x到vararr中
vararr.pushBack(x)
# 添加半定变量x和y到vararr中
vararr.pushBack([x, y])

PsdVarArray.getPsdVar()

摘要

getPsdVar(idx)

描述

根据半定变量在 PsdVarArray类 对象中的下标获取相应的半定变量,返回一个 PsdVar类 对象。

参量

idx

半定变量在 PsdVarArray类 对象中的下标。起始为0。

示例

# 获取vararr中下标为1的半定变量
var = vararr.getPsdVar(1)

PsdVarArray.getSize()

摘要

getSize()

描述

获取 PsdVarArray类 对象中元素的个数。

示例

# 获取vararr中半定变量的个数
arrsize = vararr.getSize()

SymMatrix类

SymMatrix类是半定规划模型中对称矩阵相关操作的封装,提供了以下成员方法:

SymMatrix.getIdx()

摘要

getIdx()

描述

获取对称矩阵在模型中的下标。

示例

# 获取对称矩阵mat的下标
matidx = mat.getIdx()

SymMatrix.getDim()

摘要

getDim()

描述

获取对称矩阵在模型中的维度。

示例

# 获取对称矩阵mat的维度
matdim = mat.getDim()

SymMatrixArray类

为方便用户对一组 SymMatrix类 对象进行操作,杉数求解器的Python接口设计了SymMatrixArray类, 提供了以下成员方法:

SymMatrixArray()

摘要

SymMatrixArray(mats=None)

描述

创建一个 SymMatrixArray类 对象。

若参数 matsNone,则创建一个空的 SymMatrixArray类 对象, 否则以参数 mats 初始化新创建的 SymMatrixArray类 对象。

参量

mats

待添加对称矩阵。可选参量,默认为 None。可取值为 SymMatrix类 对象、 SymMatrixArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的SymMatrixArray类对象
matarr = SymMatrixArray()
# 创建一个SymMatrixArray类对象,并使用对称矩阵matx和maty初始化
matarr = SymMatrixArray([matx, maty])

SymMatrixArray.pushBack()

摘要

pushBack(mat)

描述

添加单个或多个 SymMatrix类 对象。

参量

mat

待添加对称矩阵。可取值为 SymMatrix类 对象、SymMatrixArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加对称矩阵matx到matarr中
matarr.pushBack(matx)
# 添加对称矩阵matx和maty到matarr中
matarr.pushBack([matx, maty])

SymMatrixArray.getMatrix()

摘要

getMatrix(idx)

描述

根据对称矩阵在 SymMatrixArray类 对象中的下标获取相应的对称矩阵,返回一个 SymMatrix类 对象。

参量

idx

对称矩阵在 SymMatrixArray类 对象中的下标。起始为0。

示例

# 获取matarr中下标为1的对称矩阵
mat = matarr.getMatrix(1)

SymMatrixArray.getSize()

摘要

getSize()

描述

获取 SymMatrixArray类 对象中元素的个数。

示例

# 获取matarr中对称矩阵的个数
arrsize = matarr.getSize()

Constraint类

为了方便用户访问约束的相关信息,Constraint类提供了形如 Constraint.LB 的访问方式。 目前支持的信息详见 信息 部分。对于每个信息名,大小写无关。

此外,还可以通过 Constraint.name 访问约束的名称,通过 Constraint.pi 访问 线性规划中对偶变量的取值,通过 Constraint.basis 访问约束的基状态信息, 以及通过 Constraint.index 访问约束在系数矩阵中的下标。

对于约束的模型相关信息和约束名称,用户还可以通过形如 "Constraint.lb = -100 的方式 设置相应的信息值。

Constraint类是杉数求解器线性约束的相关操作的封装,提供了以下成员方法:

Constraint.getName()

摘要

getName()

描述

获取线性约束的名称。

示例

# 获取线性约束con的名称
conname = con.getName()

Constraint.getBasis()

摘要

getBasis()

描述

获取线性约束的基状态。

示例

# 获取线性约束con的基状态
conbasis = con.getBasis()

Constraint.getLowerIIS()

摘要

getLowerIIS()

描述

获取约束下边界的IIS状态。

示例

# 获取约束con下边界的IIS状态
lowerIIS = con.getLowerIIS()

Constraint.getUpperIIS()

摘要

getUpperIIS()

描述

获取约束上边界的IIS状态。

示例

# 获取约束con上边界的IIS状态
upperIIS = con.getUpperIIS()

Constraint.getIdx()

摘要

getIdx()

描述

获取线性约束在系数矩阵中的下标。

示例

# 获取线性约束con的下标
conidx = con.getIdx()

Constraint.setName()

摘要

setName(newname)

描述

设置线性约束的名称。

参量

newname

约束的新名称。

示例

# 设置线性约束con的名称
con.setName('con')

Constraint.getInfo()

摘要

getInfo(infoname)

描述

获取指定的信息值,返回一个常数。

参量

infoname

待获取信息名。可取值详见 信息 部分。

示例

# 获取线性约束con的下界
conlb = con.getInfo(COPT.Info.LB)

Constraint.setInfo()

摘要

setInfo(infoname, newval)

描述

设置新的信息值给指定线性约束。

参量

infoname

待设置信息名。可取值详见 信息 部分。

newval

待设置新信息值。

示例

# 设置线性约束con的下界
con.setInfo(COPT.Info.LB, 1.0)

Constraint.remove()

摘要

remove()

描述

从模型中删除当前线性约束。

示例

# 删除线性约束conx
conx.remove()

ConstrArray类

为方便用户对一组 Constraint类 对象进行操作,杉数求解器的Python接口设计了ConstrArray类, 提供了以下成员方法:

ConstrArray()

摘要

ConstrArray(constrs=None)

描述

创建一个 ConstrArray类 对象。

若参数 constrsNone,则创建一个空的 ConstrArray类 对象, 否则以参数 constrs 初始化新创建的 ConstrArray类 对象。

参量

constrs

待添加线性约束。可选参量,默认为 None。可取值为 Constraint类 对象、 ConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的ConstrArray类对象
conarr = ConstrArray()
# 创建一个ConstrArray类对象,并使用线性约束conx和cony初始化
conarr = ConstrArray([conx, cony])

ConstrArray.pushBack()

摘要

pushBack(constr)

描述

添加单个或多个 Constraint类 对象。

参量

constr

待添加线性约束。可取值为 Constraint类 对象、ConstrArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加线性约束r到conarr中
conarr.pushBack(r)
# 添加线性约束r0和r1到conarr中
conarr.pushBack([r0, r1])

ConstrArray.getConstr()

摘要

getConstr(idx)

描述

根据线性约束在 ConstrArray类 对象中的下标获取相应的线性约束, 返回一个 Constraint类 对象。

参量

idx

线性约束在 ConstrArray类 对象中的下标。起始为0。

示例

# 获取conarr中下标为1的线性约束
con = conarr.getConstr(1)

ConstrArray.getAll()

摘要

getAll()

描述

获取 ConstrArray类 对象中的全部线性约束,返回一个列表对象。

示例

# 获取conarr中的全部线性约束
cons = conarr.getAll()

ConstrArray.getSize()

摘要

getSize()

描述

获取 ConstrArray类 对象中元素的个数。

示例

# 获取conarr中线性约束的个数
arrsize = conarr.getSize()

ConstrBuilder类

ConstrBuilder类是杉数求解器中构建线性约束时的构建器的封装,提供了以下成员方法:

ConstrBuilder()

摘要

ConstrBuilder()

描述

创建一个空的 ConstrBuilder类 对象。

示例

# 创建一个空的线性约束构建器
constrbuilder = ConstrBuilder()

ConstrBuilder.setBuilder()

摘要

setBuilder(expr, sense)

描述

设置线性约束构建器的表达式和约束类型。

参量

expr

待设置表达式。可取值为 Var类 对象或 LinExpr类 对象。

sense

约束类型。可取值详见 约束类型 部分。

示例

# 设置线性约束构建器的表达式为:x + y - 1,约束类型为等于
constrbuilder.setBuilder(x + y - 1, COPT.EQUAL)

ConstrBuilder.getExpr()

摘要

getExpr()

描述

获取线性约束构建器对象的表达式。

示例

# 获取线性约束构建器的表达式
linexpr = constrbuilder.getExpr()

ConstrBuilder.getSense()

摘要

getSense()

描述

获取线性约束构建器对象的约束类型。

示例

# 获取线性约束构建器的约束类型
consense = constrbuilder.getSense()

ConstrBuilderArray类

为方便用户对一组 ConstrBuilder类 对象进行操作,杉数求解器的Python接口设计了ConstrBuilderArray类, 提供了以下成员方法:

ConstrBuilderArray()

摘要

ConstrBuilderArray(constrbuilders=None)

描述

创建一个 ConstrBuilderArray类 对象。

若参数 constrbuildersNone,则创建一个空的 ConstrBuilderArray类 对象, 否则以参数 constrbuilders 初始化新创建的 ConstrBuilderArray类 对象。

参量

constrbuilders

待添加线性约束构建器。可选参量,默认为 None。可取值为 ConstrBuilder类 对象、 ConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的ConstrBuilderArray类对象
conbuilderarr = ConstrBuilderArray()
# 创建一个ConstrBuilderArray类对象,并使用构建器对象conbuilderx和conbuildery初始化
conbuilderarr = ConstrBuilderArray([conbuilderx, conbuildery])

ConstrBuilderArray.pushBack()

摘要

pushBack(constrbuilder)

描述

添加单个或多个 ConstrBuilder类 对象。

参量

constrbuilder

待添加线性约束构建器。可取值为 ConstrBuilder类 对象、 ConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 添加线性约束构建器conbuilderx到conbuilderarr中
conbuilderarr.pushBack(conbuilderx)
# 添加线性约束构建器conbuilderx和conbuildery到conbuilderarr中
conbuilderarr.pushBack([conbuilderx, conbuildery])

ConstrBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据线性约束构建器在 ConstrBuilderArray类 对象中的下标获取相应的构建器对象。

参量

idx

线性约束构建器在 ConstrBuilderArray类 对象中的下标。起始为0。

示例

# 获取conbuilderarr中下标为1的构建器
conbuilder = conbuilderarr.getBuilder(1)

ConstrBuilderArray.getSize()

摘要

getSize()

描述

获取 ConstrBuilderArray类 对象中元素的个数。

示例

# 获取conbuilderarr中构建器的个数
arrsize = conbuilderarr.getSize()

QConstraint类

为了方便用户访问二次约束的相关信息,QConstraint类提供了形如 QConstraint.Slack 的访问方式。 目前支持的信息详见 信息 部分。对于每个信息名,大小写无关。

此外,还可以通过 QConstraint.name 访问二次约束的名称,通过 QConstraint.index 访问二次约束在模型中的下标。

对于二次约束的模型相关信息和名称,用户还可以通过形如 "QConstraint.rhs = -100 的方式 设置相应的信息值。

QConstraint类是杉数求解器二次约束的相关操作的封装,提供了以下成员方法:

QConstraint.getName()

摘要

getName()

描述

获取二次约束的名称。

示例

# 获取二次约束qcon的名称
qconname = qcon.getName()

QConstraint.getRhs()

摘要

getRhs()

描述

获取二次约束的右端项。

示例

# 获取二次约束qcon的右端项
qconrhs = qcon.getRhs()

QConstraint.getSense()

摘要

getSense()

描述

获取二次约束的约束类型。

示例

# 获取二次约束qcon的约束类型
qconsense = qcon.getSense()

QConstraint.getIdx()

摘要

getIdx()

描述

获取二次约束的下标。

示例

# 获取二次约束qcon的下标
qconidx = qcon.getIdx()

QConstraint.setName()

摘要

setName(newname)

描述

设置二次约束的名称。

参量

newname

二次约束的新名称。

示例

# 设置二次约束qcon的名称
qcon.setName('qcon')

QConstraint.setRhs()

摘要

setRhs(rhs)

设置二次约束的右端项。

参量

rhs

二次约束的新右端项。

示例

# 设置二次约束qcon的右端项为0.0
qcon.setRhs(0.0)

QConstraint.setSense()

摘要

setSense(sense)

描述

设置二次约束的约束类型。

参量

sense

二次约束的新约束类型。

示例

# 设置二次约束qcon的约束类型为小于等于
qcon.setSense(COPT.LESS_EQUAL)

QConstraint.getInfo()

摘要

getInfo(infoname)

描述

获取指定的信息值,返回一个常数。

参量

infoname

待获取信息名。可取值详见 信息 部分。

示例

# 获取二次约束qcon的当前取值
qconlb = qcon.getInfo(COPT.Info.Slack)

QConstraint.setInfo()

摘要

setInfo(infoname, newval)

描述

设置新的信息值给指定二次约束。

参量

infoname

待设置信息名。可取值详见 信息 部分。

newval

待设置新信息值。

示例

# 设置二次约束qcon的下界
qcon.setInfo(COPT.Info.LB, 1.0)

Constraint.remove()

摘要

remove()

描述

从模型中删除当前二次约束。

示例

# 删除二次约束qconx
qconx.remove()

QConstrArray类

为方便用户对一组 QConstraint类 对象进行操作,杉数求解器的Python接口设计了QConstrArray类, 提供了以下成员方法:

QConstrArray()

摘要

QConstrArray(qconstrs=None)

描述

创建一个 QConstrArray类 对象。

若参数 qconstrsNone,则创建一个空的 QConstrArray类 对象, 否则以参数 qconstrs 初始化新创建的 QConstrArray类 对象。

参量

qconstrs

待添加二次约束。可选参量,默认为 None。可取值为 QConstraint类 对象、 QConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的QConstrArray类对象
qconarr = QConstrArray()
# 创建一个QConstrArray类对象,并使用二次约束qconx和qcony初始化
qconarr = QConstrArray([qconx, qcony])

QConstrArray.pushBack()

摘要

pushBack(constr)

描述

添加单个或多个 QConstraint类 对象。

参量

constr

待添加二次约束。可取值为 QConstraint类 对象、QConstrArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加二次约束qr到qconarr中
qconarr.pushBack(qr)
# 添加二次约束qr0和qr1到qconarr中
qconarr.pushBack([qr0, qr1])

QConstrArray.getQConstr()

摘要

getQConstr(idx)

描述

根据二次约束在 QConstrArray类 对象中的下标获取相应的二次约束, 返回一个 QConstraint类 对象。

参量

idx

二次约束在 QConstrArray类 对象中的下标。起始为0。

示例

# 获取qconarr中下标为1的二次约束
qcon = qconarr.getQConstr(1)

QConstrArray.getSize()

摘要

getSize()

描述

获取 QConstrArray类 对象中元素的个数。

示例

# 获取qconarr中二次约束的个数
qarrsize = qconarr.getSize()

QConstrBuilder类

QConstrBuilder类是杉数求解器中构建二次约束时的构建器的封装,提供了以下成员方法:

QConstrBuilder()

摘要

QConstrBuilder()

描述

创建一个空的 QConstrBuilder类 对象。

示例

# 创建一个空的二次约束构建器
qconstrbuilder = QConstrBuilder()

QConstrBuilder.setBuilder()

摘要

setBuilder(expr, sense, rhs)

描述

设置二次约束构建器的表达式、约束类型和右端项。

参量

expr

待设置表达式。可取值为 Var类 对象、 LinExpr类 对象或 QuadExpr类 对象。

sense

二次约束类型。可取值详见 约束类型 部分。

rhs

二次约束右端项。

示例

# 设置二次约束构建器的表达式为:x + y,约束类型为小于等于,右端项为1.0
qconstrbuilder.setBuilder(x + y, COPT.LESS_EQUAL, 1.0)

QConstrBuilder.getQuadExpr()

摘要

getQuadExpr()

描述

获取二次约束构建器对象的表达式。

示例

# 获取二次约束构建器的表达式
quadexpr = constrbuilder.getQuadExpr()

QConstrBuilder.getSense()

摘要

getSense()

描述

获取二次约束构建器对象的约束类型。

示例

# 获取二次约束构建器的约束类型
qconsense = qconstrbuilder.getSense()

QConstrBuilderArray类

为方便用户对一组 QConstrBuilder类 对象进行操作,杉数求解器的Python接口设计了QConstrBuilderArray类, 提供了以下成员方法:

QConstrBuilderArray()

摘要

QConstrBuilderArray(qconstrbuilders=None)

描述

创建一个 QConstrBuilderArray类 对象。

若参数 qconstrbuildersNone,则创建一个空的 QConstrBuilderArray类 对象, 否则以参数 qconstrbuilders 初始化新创建的 QConstrBuilderArray类 对象。

参量

qconstrbuilders

待添加二次约束构建器。可选参量,默认为 None。可取值为 QConstrBuilder类 对象、 QConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的QConstrBuilderArray类对象
qconbuilderarr = QConstrBuilderArray()
# 创建一个QConstrBuilderArray类对象,并使用构建器对象qconbuilderx和qconbuildery初始化
qconbuilderarr = QConstrBuilderArray([qconbuilderx, qconbuildery])

QConstrBuilderArray.pushBack()

摘要

pushBack(qconstrbuilder)

描述

添加单个或多个 QConstrBuilder类 对象。

参量

qconstrbuilder

待添加二次约束构建器。可取值为 QConstrBuilder类 对象、 QConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 添加二次约束构建器qconbuilderx到qconbuilderarr中
qconbuilderarr.pushBack(qconbuilderx)
# 添加二次约束构建器qconbuilderx和qconbuildery到qconbuilderarr中
qconbuilderarr.pushBack([qconbuilderx, qconbuildery])

QConstrBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据二次约束构建器在 QConstrBuilderArray类 对象中的下标获取相应的构建器对象。

参量

idx

二次约束构建器在 QConstrBuilderArray类 对象中的下标。起始为0。

示例

# 获取qconbuilderarr中下标为1的构建器
qconbuilder = qconbuilderarr.getBuilder(1)

QConstrBuilderArray.getSize()

摘要

getSize()

描述

获取 QConstrBuilderArray类 对象中元素的个数。

示例

# 获取qconbuilderarr中构建器的个数
qarrsize = qconbuilderarr.getSize()

PsdConstraint类

PsdConstraint类是杉数求解器半定约束的相关操作的封装,提供了以下成员方法:

PsdConstraint.getName()

摘要

getName()

描述

获取半定约束的名称。

示例

# 获取半定约束con的名称
conname = con.getName()

PsdConstraint.getIdx()

摘要

getIdx()

描述

获取半定约束在模型中的下标。

示例

# 获取半定约束con的下标
conidx = con.getIdx()

PsdConstraint.setName()

摘要

setName(newname)

描述

设置半定约束的名称。

参量

newname

半定约束的新名称。

示例

# 设置半定约束con的名称
con.setName('con')

PsdConstraint.getInfo()

摘要

getInfo(infoname)

描述

获取指定的信息值,返回一个常数。

参量

infoname

待获取信息名。可取值详见 信息 部分。

示例

# 获取半定约束con的下界
conlb = con.getInfo(COPT.Info.LB)

PsdConstraint.setInfo()

摘要

setInfo(infoname, newval)

描述

设置新的信息值给指定半定约束。

参量

infoname

待设置信息名。可取值详见 信息 部分。

newval

待设置新信息值。

示例

# 设置半定约束con的下界
con.setInfo(COPT.Info.LB, 1.0)

PsdConstraint.remove()

摘要

remove()

描述

从模型中删除当前半定约束。

示例

# 删除半定约束conx
conx.remove()

PsdConstrArray类

为方便用户对一组 PsdConstraint类 对象进行操作,杉数求解器的Python接口设计了PsdConstrArray类, 提供了以下成员方法:

PsdConstrArray()

摘要

PsdConstrArray(constrs=None)

描述

创建一个 PsdConstrArray类 对象。

若参数 constrsNone,则创建一个空的 PsdConstrArray类 对象, 否则以参数 constrs 初始化新创建的 PsdConstrArray类 对象。

参量

constrs

待添加半定约束。可选参量,默认为 None。可取值为 PsdConstraint类 对象、 PsdConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的PsdConstrArray类对象
conarr = PsdConstrArray()
# 创建一个PsdConstrArray类对象,并使用半定约束conx和cony初始化
conarr = PsdConstrArray([conx, cony])

PsdConstrArray.pushBack()

摘要

pushBack(constr)

描述

添加单个或多个 PsdConstraint类 对象。

参量

constr

待添加半定约束。可取值为 PsdConstraint类 对象、PsdConstrArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加半定约束r到conarr中
conarr.pushBack(r)
# 添加半定约束r0和r1到conarr中
conarr.pushBack([r0, r1])

PsdConstrArray.getPsdConstr()

摘要

getPsdConstr(idx)

描述

根据半定约束在 PsdConstrArray类 对象中的下标获取相应的半定约束, 返回一个 PsdConstraint类 对象。

参量

idx

半定约束在 PsdConstrArray类 对象中的下标。起始为0。

示例

# 获取conarr中下标为1的半定约束
con = conarr.getPsdConstr(1)

PsdConstrArray.getSize()

摘要

getSize()

描述

获取 PsdConstrArray类 对象中元素的个数。

示例

# 获取conarr中半定约束的个数
arrsize = conarr.getSize()

PsdConstrBuilder类

PsdConstrBuilder类是杉数求解器中构建线性约束时的构建器的封装,提供了以下成员方法:

PsdConstrBuilder()

摘要

PsdConstrBuilder()

描述

创建一个空的 PsdConstrBuilder类 对象。

示例

# 创建一个空的半定约束构建器
constrbuilder = PsdConstrBuilder()

PsdConstrBuilder.setBuilder()

摘要

setBuilder(expr, sense, rhs)

描述

设置半定约束构建器的表达式、约束类型和右端项。

参量

expr

待设置表达式。可取值为 PsdVar类 对象或 PsdExpr类 对象。

sense

约束类型。可取值详见 约束类型 部分。

rhs

约束右端项。

示例

# 设置半定约束构建器的表达式为:x + y == 1,约束类型为等于
constrbuilder.setBuilder(x + y, COPT.EQUAL, 1)

PsdConstrBuilder.setRange()

摘要

setRange(expr, range)

描述

设置半定约束构建器的表达式和右端项, 形式为 expr 小于等于0, 且大于等于 - range.

参量

expr

待设置表达式。可取值为 PsdVar类 对象或 PsdExpr类 对象。

range

Range约束的右端项, 非负。

示例

# 设置半定约束构建器的表达式为:x + y - 1,range右端项为1
constrbuilder.setRange(x + y - 1, 1)

PsdConstrBuilder.getPsdExpr()

摘要

getPsdExpr()

描述

获取半定约束构建器对象的表达式。

示例

# 获取半定约束构建器的表达式
psdexpr = constrbuilder.getPsdExpr()

PsdConstrBuilder.getSense()

摘要

getSense()

描述

获取半定约束构建器对象的约束类型。

示例

# 获取线性约束构建器的约束类型
consense = constrbuilder.getSense()

PsdConstrBuilder.getRange()

摘要

getRange()

描述

获取半定约束构建器对象的range右端项, 即约束上下界之差。

示例

# 获取线性约束构建器的range右端项
rngval = constrbuilder.getRange()

PsdConstrBuilderArray类

为方便用户对一组 PsdConstrBuilder类 对象进行操作,杉数求解器的Python接口设计了PsdConstrBuilderArray类, 提供了以下成员方法:

PsdConstrBuilderArray()

摘要

PsdConstrBuilderArray(builders=None)

描述

创建一个 PsdConstrBuilderArray类 对象。

若参数 buildersNone,则创建一个空的 PsdConstrBuilderArray类 对象, 否则以参数 builders 初始化新创建的 PsdConstrBuilderArray类 对象。

参量

builders

待添加半定约束构建器。可选参量,默认为 None。可取值为 PsdConstrBuilder类 对象、 PsdConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的PsdConstrBuilderArray类对象
conbuilderarr = PsdConstrBuilderArray()
# 创建一个PsdConstrBuilderArray类对象,并使用构建器对象conbuilderx和conbuildery初始化
conbuilderarr = PsdConstrBuilderArray([conbuilderx, conbuildery])

PsdConstrBuilderArray.pushBack()

摘要

pushBack(builder)

描述

添加单个或多个 PsdConstrBuilder类 对象。

参量

builder

待添加半定约束构建器。可取值为 PsdConstrBuilder类 对象、 PsdConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 添加半定约束构建器conbuilderx到conbuilderarr中
conbuilderarr.pushBack(conbuilderx)
# 添加半定约束构建器conbuilderx和conbuildery到conbuilderarr中
conbuilderarr.pushBack([conbuilderx, conbuildery])

PsdConstrBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据半定约束构建器在 PsdConstrBuilderArray类 对象中的下标获取相应的构建器对象。

参量

idx

半定约束构建器在 PsdConstrBuilderArray类 对象中的下标。起始为0。

示例

# 获取conbuilderarr中下标为1的构建器
conbuilder = conbuilderarr.getBuilder(1)

PsdConstrBuilderArray.getSize()

摘要

getSize()

描述

获取 PsdConstrBuilderArray类 对象中元素的个数。

示例

# 获取conbuilderarr中构建器的个数
arrsize = conbuilderarr.getSize()

LmiConstraint类

LmiConstraint类是杉数求解器LMI约束的相关操作的封装,提供了以下成员方法:

LmiConstraint.getName()

摘要

getName()

描述

获取LMI约束的名称。

示例

# 获取LMI约束con的名称
conname = con.getName()

LmiConstraint.getIdx()

摘要

getIdx()

描述

获取LMI约束在模型中的下标。

示例

# 获取LMI约束con的下标
conidx = con.getIdx()

LmiConstraint.getDim()

摘要

getDim()

描述

获取LMI约束的维度。

示例

# 获取LMI约束con的维度
conidx = con.getDim()

LmiConstraint.getLen()

摘要

getLen()

描述

获取LMI约束展开后的长度。

示例

# 获取LMI约束展开后的长度
conidx = con.getLen()

LmiConstraint.setName()

摘要

setName(newname)

描述

设置LMI约束的名称。

参量

newname

LMI约束的新名称。

示例

# 设置LMI约束con的名称
con.setName('con')

LmiConstraint.setRhs()

摘要

setRhs(mat)

描述

设置LMI约束的常数项对称矩阵。

参量

mat

LMI约束的常数项对称矩阵,需要为 SymMatrix类 类对象。

示例

# 设置LMI约束con的常数项对称矩阵
D = m.addSparseMat(2, [0, 1], [0, 1], [1.0, 1.0])
con.setRhs(D)

LmiConstraint.getInfo()

摘要

getInfo(infoname)

描述

获取LMI约束指定信息 infoname 的取值。

参量

infoname

待获取信息名。可取值为 "Slack""Dual"

示例

# 获取LMI约束con松弛变量的取值
con_slack = con.getInfo("Slack")
# 获取LMI约束con的对偶变量取值
con_dual = con.getInfo("Dual")

LmiConstraint.remove()

摘要

remove()

描述

从模型中删除当前LMI约束。

示例

# 删除LMI约束conx
conx.remove()

LmiConstraint.shape

摘要

shape

描述

LmiConstraint 对象的形状。

返回值

整型元组。

LmiConstraint.size

摘要

size

描述

LmiConstraint 对象的形状。

返回值

整型元组。

LmiConstraint.dim

摘要

dim

描述

LmiConstraint 对象的维度。

返回值

整型值。

LmiConstraint.len

摘要

len

描述

LmiConstraint 对象展开后的长度。

返回值

整型值。

LmiConstrArray类

为方便用户对一组 LmiConstraint类 对象进行操作,杉数求解器的Python接口设计了LmiConstrArray类, 提供了以下成员方法:

LmiConstrArray()

摘要

LmiConstrArray(constrs=None)

描述

创建一个 LmiConstrArray类 对象。

若参数 constrsNone,则创建一个空的 LmiConstrArray类 对象, 否则以参数 constrs 初始化新创建的 LmiConstrArray类 对象。

参量

constrs

待添加的LMI约束。可选参量,默认为 None。可取值为 LmiConstraint类 对象、 LmiConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的LmiConstrArray类对象
conarr = LmiConstrArray()
# 创建一个LmiConstrArray类对象,并使用LMI约束conx和cony初始化
conarr = LmiConstrArray([conx, cony])

LmiConstrArray.pushBack()

摘要

pushBack(constr)

描述

LmiConstrArray 中添加单个或多个 LmiConstraint类 对象。

参量

constr

待添加LMI约束。可取值为 LmiConstraint类 对象、LmiConstrArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加LMI约束r到conarr中
conarr.pushBack(r)
# 添加LMI约束r0和r1到conarr中
conarr.pushBack([r0, r1])

LmiConstrArray.getLmiConstr()

摘要

getLmiConstr(idx)

描述

根据LMI约束在 LmiConstrArray类 对象中的下标获取相应的LMI约束, 返回一个 LmiConstraint类 对象。

参量

idx

LMI约束在 LmiConstrArray类 对象中的下标。起始为0。

示例

# 获取conarr中下标为1的LMI约束
con = conarr.getLmiConstr(1)

LmiConstrArray.getSize()

摘要

getSize()

描述

获取 LmiConstrArray类 对象中元素的个数。

示例

# 获取conarr中Lmi约束的个数
arrsize = conarr.getSize()

LmiConstrArray.reserve()

摘要

reserve(n)

描述

为大小为 n 的 LmiConstrArray类 对象保留空间。

参量

n

LmiConstrArray类 对象中元素的个数。

SOS类

SOS类是杉数求解器的SOS约束的相关操作的封装,目前提供了以下成员方法:

关于SOS约束的介绍请参考 特殊约束:SOS约束 章节

SOS.getIdx()

摘要

getIdx()

描述

获取SOS约束在模型中的下标。

示例

# 获取SOS约束sosx的下标
sosidx = sosx.getIdx()

SOS.remove()

摘要

remove()

描述

从模型中删除当前SOS约束。

示例

# 删除SOS约束sosx
sosx.remove()

SOSArray类

为方便用户对一组 SOS类 对象进行操作,杉数求解器的Python接口设计了SOSArray类, 提供了以下成员方法:

SOSArray()

摘要

SOSArray(soss=None)

描述

创建一个 SOSArray类 对象。

若参数 sossNone,则创建一个空的 SOSArray类 对象, 否则以参数 soss 初始化新创建的 SOSArray类 对象。

参量

soss

待添加SOS约束。可选参量,默认为 None。可取值为 SOS类 对象、 SOSArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个新的SOSArray对象
sosarr = SOSArray()
# 创建一个SOSArray对象,并使用SOS约束sosx和sosy初始化
sosarr = SOSArray([sosx, sosy])

SOSArray.pushBack()

摘要

pushBack(sos)

描述

添加单个或多个 SOS类 对象。

参量

sos

待添加SOS约束。可取值为 SOS类 对象、SOSArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加SOS约束sosx到sosarr中
sosarr.pushBack(sosx)
# 添加SOS约束sosx和sosy到sosarr中
sosarr.pushBack([sosx, sosy])

SOSArray.getSOS()

摘要

getSOS(idx)

描述

根据SOS约束在 SOSArray类 对象中的下标获取相应的SOS约束, 返回一个 SOS类 对象。

参量

idx

SOS约束在 SOSArray类 对象中的下标。起始为0。

示例

# 获取sosarr中下标为1的SOS约束
sos = sosarr.getSOS(1)

SOSArray.getSize()

摘要

getSize()

描述

获取 SOSArray类 对象中元素的个数。

示例

# 获取sosarr中SOS约束的个数
arrsize = sosarr.getSize()

SOSBuilder类

SOSBuilder类是杉数求解器中构建SOS约束的构建器的封装,提供了以下成员方法:

关于SOS约束的介绍请参考 特殊约束:SOS约束 章节

SOSBuilder()

摘要

SOSBuilder()

描述

创建一个空的 SOSBuilder类 对象。

示例

# 创建一个空的SOSBuilder对象
sosbuilder = SOSBuilder()

SOSBuilder.setBuilder()

摘要

setBuilder(sostype, vars, weights=None)

描述

设置 SOSBuilder类 对象的类型、变量和变量权重。

参量

sostype

SOS约束类型,可取值详见 SOS约束类型

vars

SOS约束的变量,可取值为 VarArray类 对象、列表、字典或 tupledict类 对象。

weights

SOS约束的变量的权重。可选取值,默认为 None。 可取值为列表、字典或 tupledict类 对象。

示例

# 设置SOS约束构建器的类型为SOS1,变量为x和y,变量的权重分别为1和2
sosbuilder.setBuilder(COPT.SOS_TYPE1, [x, y], [1, 2])

SOSBuilder.getType()

摘要

getType()

描述

获取 SOSBuilder类 对象的SOS约束类型。

示例

# 获取SOS约束构建器sosx的类型
sostype = sosbuilder.getType(sosx)

SOSBuilder.getVar()

摘要

getVar(idx)

描述

根据变量在 SOSBuilder类 对象的下标获取相应的变量, 返回一个 Var类 对象。

参量

idx

变量在 SOSBuilder类 对象中的下标。起始为0。

示例

# 获取SOS约束构建器sosx中下标为1的变量
sosvar = sosx.getVar(1)

SOSBuilder.getVars()

摘要

getVars()

描述

获取 SOSBuilder类 对象的所有变量, 返回一个 VarArray类 对象。

示例

# 获取SOS约束构建器sosx中的所有变量
sosvars = sosx.getVars()

SOSBuilder.getWeight()

摘要

getWeight(idx)

描述

根据变量在 SOSBuilder类 对象的下标获取相应的变量权重。

参量

idx

变量在 SOSBuilder类 对象中的下标。起始为0。

示例

# 获取SOS约束构建器sosx中下标为1的变量相应的权重
sosweight = sosx.getWeight(1)

SOSBuilder.getWeights()

摘要

getWeights()

描述

获取 SOSBuilder类 对象中所有变量的权重。

示例

# 获取SOS约束构建器sosx中所有变量的权重
sosweights = sosx.getWeights()

SOSBuilder.getSize()

摘要

getSize()

描述

获取 SOSBuilder类 对象中元素的个数。

示例

# 获取SOS约束构建器sosx中元素的个数
sossize = sosx.getSize()

SOSBuilderArray类

为方便用户对一组 SOSBuilder类 对象进行操作,杉数求解器的Python接口设计了SOSBuilderArray类, 提供了以下成员方法:

SOSBuilderArray()

摘要

SOSBuilderArray(sosbuilders=None)

描述

创建一个 SOSBuilderArray类 对象。

若参数 sosbuildersNone,则创建一个空的 SOSBuilderArray类 对象, 否则以参数 sosbuilders 初始化新创建的 SOSBuilderArray类 对象。

参量

sosbuilders

待添加SOS约束构建器。可选参量,默认为 None。可取值为 SOSBuilder类 对象、 SOSBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的SOSBuilderArray对象
sosbuilderarr = SOSBuilderArray()
# 创建一个SOSBuilderArray对象,并使用SOS约束构建器sosx和sosy初始化
sosbuilderarr = SOSBuilderArray([sosx, sosy])

SOSBuilderArray.pushBack()

摘要

pushBack(sosbuilder)

描述

添加单个或多个 SOSBuilder类 对象。

参量

sosbuilder

待添加SOS约束构建器。可取值为 SOSBuilder类 对象、SOSBuilderArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加SOS约束构建器sosx到sosbuilderarr中
sosbuilderarr.pushBack(sosx)

SOSBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据SOS约束构建器在 SOSBuilderArray类 对象中的下标获取相应的构建器。

参量

idx

SOS约束构建器在 SOSBuilderArray类 对象中的下标。起始为0。

示例

# 获取sosbuilderarr中下标为1的SOS约束构建器
sosbuilder = sosbuilderarr.getBuilder(1)

SOSBuilderArray.getSize()

摘要

getSize()

描述

获取 SOSBuilderArray类 对象中元素的个数。

示例

# 获取sosbuilderarr中元素的个数
sosbuildersize = sosbuilderarr.getSize()

Cone类

Cone类是杉数求解器的二阶锥约束的相关操作的封装,目前提供了以下成员方法:

Cone.getIdx()

摘要

getIdx()

描述

获取二阶锥约束在模型中的下标。

示例

# 获取二阶锥约束cone的下标
coneidx = cone.getIdx()

Cone.remove()

摘要

remove()

描述

从模型中删除当前二阶锥约束。

示例

# 删除二阶锥约束cone
cone.remove()

ConeArray类

为方便用户对一组 Cone类 对象进行操作,杉数求解器的Python接口设计了ConeArray类, 提供了以下成员方法:

ConeArray()

摘要

ConeArray(cones=None)

描述

创建一个 ConeArray类 对象。

若参数 conesNone,则创建一个空的 ConeArray类 对象, 否则以参数 cones 初始化新创建的 ConeArray类 对象。

参量

cones

待添加二阶锥约束。可选参量,默认为 None。可取值为 Cone类 对象、 ConeArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个新的ConeArray对象
conearr = ConeArray()
# 创建一个ConeArray对象,并使用二阶锥约束conex和coney初始化
conearr = ConeArray([conex, coney])

ConeArray.pushBack()

摘要

pushBack(cone)

描述

添加单个或多个 Cone类 对象。

参量

cone

待添加二阶锥约束。可取值为 Cone类 对象、ConeArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加二阶锥约束conex到conearr中
conearr.pushBack(conex)
# 添加二阶锥约束conex和coney到conearr中
conearr.pushBack([conex, coney])

ConeArray.getCone()

摘要

getCone(idx)

描述

根据二阶锥约束在 ConeArray类 对象中的下标获取相应的二阶锥约束, 返回一个 Cone类 对象。

参量

idx

二阶锥约束在 ConeArray类 对象中的下标。起始为0。

示例

# 获取conearr中下标为1的二阶锥约束
cone = conearr.getCone(1)

ConeArray.getSize()

摘要

getSize()

描述

获取 ConeArray类 对象中元素的个数。

示例

# 获取conearr中二阶锥约束的个数
arrsize = conearr.getSize()

ConeBuilder类

ConeBuilder类是杉数求解器中构建二阶锥约束的构建器的封装,提供了以下成员方法:

ConeBuilder()

摘要

ConeBuilder()

描述

创建一个空的 ConeBuilder类 对象。

示例

# 创建一个空的ConeBuilder对象
conebuilder = ConeBuilder()

ConeBuilder.setBuilder()

摘要

setBuilder(conetype, vars)

描述

设置 ConeBuilder类 对象的类型、变量。

参量

conetype

二阶锥约束类型,可取值详见 二阶锥约束类型

vars

二阶锥约束的变量,可取值为 VarArray类 对象、列表、字典或 tupledict类 对象。

示例

# 设置二阶锥约束构建器的类型为标准二阶锥
conebuilder.setBuilder(COPT.CONE_QUAD, [z, x, y])

ConeBuilder.getType()

摘要

getType()

描述

获取 ConeBuilder类 对象的二阶锥约束类型。

示例

# 获取二阶锥约束构建器conex的类型
conetype = conebuilder.getType(conex)

ConeBuilder.getVar()

摘要

getVar(idx)

描述

根据变量在 ConeBuilder类 对象的下标获取相应的变量, 返回一个 Var类 对象。

参量

idx

变量在 ConeBuilder类 对象中的下标。起始为0。

示例

# 获取二阶锥约束构建器conex中下标为1的变量
conevar = conex.getVar(1)

ConeBuilder.getVars()

摘要

getVars()

描述

获取 ConeBuilder类 对象的所有变量, 返回一个 VarArray类 对象。

示例

# 获取二阶锥约束构建器conex中的所有变量
conevars = conex.getVars()

ConeBuilder.getSize()

摘要

getSize()

描述

获取 ConeBuilder类 对象中元素的个数。

示例

# 获取二阶锥约束构建器conex中元素的个数
conesize = conex.getSize()

ConeBuilderArray类

为方便用户对一组 ConeBuilder类 对象进行操作,杉数求解器的Python接口设计了ConeBuilderArray类, 提供了以下成员方法:

ConeBuilderArray()

摘要

ConeBuilderArray(conebuilders=None)

描述

创建一个 ConeBuilderArray类 对象。

若参数 conebuildersNone,则创建一个空的 ConeBuilderArray类 对象, 否则以参数 conebuilders 初始化新创建的 ConeBuilderArray类 对象。

参量

conebuilders

待添加二阶锥约束构建器。可选参量,默认为 None。可取值为 ConeBuilder类 对象、 ConeBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的ConeBuilderArray对象
conebuilderarr = ConeBuilderArray()
# 创建一个ConeBuilderArray对象,并使用二阶锥约束构建器conex和coney初始化
conebuilderarr = ConeBuilderArray([conex, coney])

ConeBuilderArray.pushBack()

摘要

pushBack(conebuilder)

描述

添加单个或多个 ConeBuilder类 对象。

参量

conebuilder

待添加二阶锥约束构建器。可取值为 ConeBuilder类 对象、ConeBuilderArray类 对象、 列表、字典或 tupledict类 对象。

示例

# 添加二阶锥约束构建器conex到conebuilderarr中
conebuilderarr.pushBack(conex)

ConeBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据二阶锥约束构建器在 ConeBuilderArray类 对象中的下标获取相应的构建器。

参量

idx

二阶锥约束构建器在 ConeBuilderArray类 对象中的下标。起始为0。

示例

# 获取conebuilderarr中下标为1的二阶锥约束构建器
conebuilder = conebuilderarr.getBuilder(1)

ConeBuilderArray.getSize()

摘要

getSize()

描述

获取 ConeBuilderArray类 对象中元素的个数。

示例

# 获取conebuilderarr中元素的个数
conebuildersize = conebuilderarr.getSize()

GenConstr类

GenConstr类是杉数求解器的Indicator约束的相关操作的封装,提供了以下成员方法:

关于Indicator约束的介绍请参考 特殊约束:Indicator约束 章节

GenConstr.getIdx()

摘要

getIdx()

描述

获取Indicator约束在模型中的下标。

示例

# 获取Indicator约束indicx的下标
indidx = indicx.getIdx()

GenConstr.remove()

摘要

remove()

描述

从模型中删除当前Indicator约束。

示例

# 删除Indicator约束indx
indx.remove()

GenConstrArray类

为方便用户对一组 GenConstr类 对象进行操作,杉数求解器的Python接口设计了 GenConstrArray类,提供了以下成员方法:

GenConstrArray()

摘要

GenConstrArray(genconstrs=None)

描述

创建一个 GenConstrArray类 对象。

若参数 genconstrsNone,则创建一个空的 GenConstrArray类 对象, 否则以参数 genconstrs 初始化新创建的 GenConstrArray类 对象。

参量

genconstrs

待添加Indicator约束。可选参量,默认为 None。可取值为 GenConstr类 对象、 GenConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个新的GenConstrArray对象
genconstrarr = GenConstrArray()
# 创建一个GenConstrArray对象,并使用Indicator约束genx和geny初始化
genconstrarr = GenConstrArray([genx, geny])

GenConstrArray.pushBack()

摘要

pushBack(genconstr)

描述

添加单个或多个 GenConstr类 对象。

参量

constrs

待添加Indicator约束。可取值为 GenConstr类 对象、 GenConstrArray类 对象、列表、字典或 tupledict类 对象。

示例

# 添加Indicator约束genx到genconarr中
genconarr.pushBack(genx)
# 添加Indicator约束genx和geny到genconarr中
genconarr.pushBack([genx, geny])

GenConstrArray.getGenConstr()

摘要

getGenConstr(idx)

描述

根据Indicator约束在 GenConstrArray类 对象中的下标获取相应的Indicator约束, 返回一个 GenConstr类 对象。

参量

idx

Indicator约束在 GenConstrArray类 对象中的下标。起始为0。

示例

# 获取genconarr中下标为1的Indicator约束
genconstr = genconarr.getGenConstr(1)

GenConstrArray.getSize()

摘要

getSize()

描述

获取 GenConstrArray类 对象中的元素个数。

示例

# 获取genconarr中元素的个数
genconsize = genconarr.getSize()

GenConstrBuilder类

GenConstrBuilder类是杉数求解器中构建Indicator约束时的构建器的封装,提供了以下成员方法:

关于Indicator约束的介绍请参考 特殊约束:Indicator约束 章节

GenConstrBuilder()

摘要

GenConstrBuilder()

描述

创建一个空的 GenConstrBuilder类 对象。

示例

# 创建一个空的GenConstrBuilder对象
genconbuilder = GenConstrBuilder()

GenConstrBuilder.setBuilder()

摘要

setBuilder(var, val, expr, sense)

描述

设置 GenConstrBuilder类 对象的Indicator变量、Indicator变量 的取值、线性约束表达式和线性约束的类型。

参量

var

Indicator变量。

val

Indicator变量的取值。

expr

线性约束的表达式。可取值为 Var类 对象或 LinExpr类 对象。

sense

线性约束的类型。可取值详见 约束类型

示例

# 设置Indicator约束构建器的Indicator变量为x,当x为真时,线性约束x + y == 1成立
genconbuilder.setBuilder(x, True, x + y - 1, COPT.EQUAL)

GenConstrBuilder.getBinVar()

摘要

getBinVar()

描述

获取 GenConstrBuilder类 对象的Indicator变量。

示例

# 获取Indicator约束构建器genbuilderx的Indicator变量
indvar = genbuilderx.getBinVar()

GenConstrBuilder.getBinVal()

摘要

getBinVal()

描述

获取 GenConstrBuilder类 对象的Indicator变量的取值。

示例

# 获取Indicator约束构建器genbuilderx的Indicator变量有效时的取值
indval = genbuilderx.getBinVal()

GenConstrBuilder.getExpr()

摘要

getExpr()

描述

获取 GenConstrBuilder类 对象的线性约束表达式。

示例

# 获取Indicator约束构建器genbuilderx的线性约束表达式
linexpr = genbuilderx.getExpr()

GenConstrBuilder.getSense()

摘要

getSense()

描述

获取 GenConstrBuilder类 对象的线性约束类型。

示例

# 获取Indicator约束构建器genbuilderx的线性约束类型。
linsense = genbuilderx.getSense()

GenConstrBuilderArray类

为方便用户对一组 GenConstrBuilder类 对象进行操作,杉数求解器的Python接口设计了GenConstrBuilderArray类, 提供了以下成员方法:

GenConstrBuilderArray()

摘要

GenConstrBuilderArray(genconstrbuilders=None)

描述

创建一个 GenConstrBuilderArray类 对象。

若参数 genconstrbuildersNone,则创建一个空的 GenConstrBuilderArray类 对象, 否则以参数 genconstrbuilders 初始化新创建的 GenConstrBuilderArray类 对象。

参量

genconstrbuilders

待添加Indicator约束构建器。可选参量,默认为 None。可取值为 GenConstrBuilder类 对象、 GenConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的GenConstrBuilderArray对象
genbuilderarr = GenConstrBuilderArray()
# 创建一个GenConstrBuilderArray对象,并使用Indicator约束构建器genbuilderx和genbuildery初始化
genbuilderarr = GenConstrBuilderArray([genbuilderx, genbuildery])

GenConstrBuilderArray.pushBack()

摘要

pushBack(genconstrbuilder)

描述

添加单个或多个 GenConstrBuilder类 对象。

参量

genconstrbuilder

待添加Indicator约束构建器。可取值为 GenConstrBuilder类 对象、 GenConstrBuilderArray类 对象、列表、字典或 tupledict类 对象。

示例

# 添加Indicator约束构建器到genbuilderarr中
genbuilderarr.pushBack(genbuilderx)
# 添加Indicator约束构建器genbuilderx和genbuildery到genbuilderarr中
genbuilderarr.pushBack([genbuilderx, genbuildery])

GenConstrBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据Indicator约束构建器在 GenConstrBuilderArray类 对象中的下标获取相应的构建器, 返回一个 GenConstrBuilder类 对象。

参量

idx

Indicator约束构建器在 GenConstrBuilderArray类 对象中的下标。起始为0。

示例

# 获取genbuilderarr中下标为1的Indicator约束构建器
genbuilder = genbuilderarr.getBuilder(1)

GenConstrBuilderArray.getSize()

摘要

getSize()

描述

获取 GenConstrBuilderArray类 对象中元素的个数。

示例

# 获取genbuilderarr中元素的个数
genbuildersize = genbuilderarr.getSize()

Column类

为了方便用户采用按列建模的方式,杉数求解器的Python接口设计了Column类,提供了以下成员方法:

Column()

摘要

Column(constrs=0.0, coeffs=None)

描述

创建一个 Column类 对象。

若参数 constrsNone,参数 coeffsNone,则创建一个空的 Column类 对象, 否则采用参数 constrscoeffs 初始化新创建的 Column类 对象。 若参数 constrsConstraint类 对象或 Column类 对象,则参数 coeffs 为常数, 当参数 coeffsNone,则当作常数1.0; 若参数 constrs 为列表对象,参数 coeffsNone,则参数 constrs 中的元素为约束、系数对; 对于其它参数情形,则调用成员方法 addTerms 初始化新创建的 Column类 对象。

参量

constrs

线性约束。

coeffs

变量在线性约束中的系数。

示例

# 创建一个空的Column对象
col = Column()
# 创建一个Column对象,并添加两个项:约束conx中变量系数为2,约束cony中变量系数为3
col = Column([(conx, 2), (cony, 3)])
# 创建一个Column对象,并添加两个项:约束conxx中变量系数为1,约束conyy中变量系数为2
col = Column([conxx, conyy], [1, 2])

Column.getCoeff()

摘要

getCoeff(idx)

描述

根据元素在 Column类 对象中的下标获取相应系数。

参量

idx

元素的下标。起始为0。

示例

# 获取col中下标为0的项对应的系数
coeff = col.getCoeff(0)

Column.getConstr()

摘要

getConstr(idx)

描述

根据元素在 Column类 对象中的下标获取相应线性约束。

参量

idx

元素的下标。起始为0。

示例

# 获取col中下标为1的项对应的线性约束
constr = col.getConstr(1)

Column.getSize()

摘要

getSize()

描述

获取 Column类 对象中元素的个数。

示例

# 获取col中元素的个数
colsize = col.getSize()

Column.addTerm()

摘要

addTerm(constr, coeff=1.0)

描述

添加一个新的项。

参量

constr

待添加项对应的线性约束。

coeff

待添加项的系数。可选参量,默认值为1.0。

示例

# 添加一个项到col,其约束为cony,系数为2.0
col.addTerm(cony, 2.0)
# 添加一个项到col,其约束为conx,系数为1.0
col.addTerm(conx)

Column.addTerms()

摘要

addTerms(constrs, coeffs)

描述

添加单个或多个新项。

若参数 constrsConstraint类 对象,则参数 coeffs 为常数; 若参数 constrsConstrArray类 对象或列表对象,则参数 coeffs 为常数或列表对象; 若参数 constrs 为 字典对象或 tupledict类 对象,则参数 coeffs 为常数、字典或 tupledict类 对象。

参量

constrs

待添加项对应的约束。

coeffs

待添加项对应的系数。

示例

# 添加两个项:约束conx中变量系数为2.0,约束cony中变量系数为3.0
col.addTerms([conx, cony], [2.0, 3.0])

Column.addColumn()

摘要

addColumn(col, mult=1.0)

描述

添加新的列到当前列中。

参量

col

待添加列对象。

mult

待添加列的放大系数。可选参量,默认值为1.0。

示例

# 添加列coly中的项到列colx中,coly中的项放大系数为2.0
colx.addColumn(coly, 2.0)

Column.clone()

摘要

clone()

描述

创建列对象的深拷贝。

示例

# 创建列col的深拷贝
colcopy = col.clone()

Column.remove()

摘要

remove(item)

描述

从列对象中移除指定的项。

若参数 item 为常数,则移除指定下标对应的项;否则参数 itemConstraint类 对象。

参量

item

常数下标或待移除项相应的线性约束。

示例

# 从列col中移除下标为2相应的项
col.remove(2)
# 从列col中移除线性约束conx所在的项
col.remove(conx)

Column.clear()

摘要

clear()

描述

清空列对象中的内容。

示例

# 清空列col中的内容
col.clear()

ColumnArray类

为方便用户对一组 Column类 对象进行操作,杉数求解器的Python接口设计了ColumnArray类, 提供了以下成员方法:

ColumnArray()

摘要

ColumnArray(columns=None)

描述

创建一个 ColumnArray类 对象。

若参数 columnsNone,则创建一个空的 ColumnArray类 对象, 否则以参数 columns 初始化新创建的 ColumnArray类 对象。

参量

columns

待添加列。可选参量,默认为 None。可取值为 Column类 对象、 ColumnArray类 对象、列表、字典或 tupledict类 对象。

示例

# 创建一个空的ColumnArray对象
colarr = ColumnArray()
# 创建一个ColumnArray对象,并使用列colx和coly初始化
colarr = ColumnArray([colx, coly])

ColumnArray.pushBack()

摘要

pushBack(column)

描述

添加单个或多个 Column类 对象。

参量

column

待添加列。可取值为 Column类 对象、 ColumnArray类 对象、列表、字典 或 tupledict类 对象。

示例

# 添加列colx到colarr中
colarr.pushBack(colx)
# 添加列colx和coly到colarr中
colarr.pushBack([colx, coly])

ColumnArray.getColumn()

摘要

getColumn(idx)

描述

根据列在 ColumnArray类 对象中的下标获取相应的列, 返回一个 Column类 对象。

参量

idx

列在 ColumnArray类 对象中的下标。起始为0。

示例

# 获取colarr中下标为1的列
col = colarr.getColumn(1)

ColumnArray.getSize()

摘要

getSize()

描述

获取 ColumnArray类 对象中元素的个数。

示例

# 获取colarr中元素的个数
colsize = colarr.getSize()

ColumnArray.clear()

摘要

clear()

描述

清空 ColumnArray类 对象中的内容。

示例

# 清空colarr中的内容
colarr.clear()

MVar类

MVar类是杉数求解器中用于构建多维变量,并支持NumPy的多维数组运算的类。 我们建议通过模型类的方法addVars或者addMVar来生成,虽然也可以通过fromlist和fromvar这两个内置类方法转换生成。 提供了以下成员方法:

MVar.fromlist()

摘要

fromlist(vars)

描述

从一组 Var类 对象生成一个 MVar类 对象。 这是类生成方法,可以直接调用,无需MVar对象。

参量

vars

一组Var对象,可以是多维的list,或者ndarray。

返回值

新的MVar对象,其维度取决于参量vars的维度。

示例

vars = model.addVars(4)
mx_1d = MVar.fromlist(vars)
mx_2d = MVar.fromlist([vars[0], vars[1]], [vars[2], vars[3]])

MVar.fromvar()

摘要

fromvar(var)

描述

从一个 Var类 对象生成一个0维的 MVar类 对象。 这是类生成方法,可以直接调用,无需MVar对象。

参量

var

一个Var对象。

返回值

新的0维MVar对象。

示例

x = model.addVar()
mx_0d = MVar.fromvar(x)

MVar.clone()

摘要

clone()

描述

深度复制一个 MVar类 对象。

返回值

新的MVar对象

示例

# 创建一个2-D变量,并复制一份。注意实际变量没有增加。
mx = model.addMVar((3, 2), nameprefix="mx")
mx_copy = mx.clone()

MVar.diagonal()

摘要

diagonal(offset=0, axis1=0, axis2=1)

描述

生成一个 MVar类 对象,其元素是原MVar对象对角线上的元素。

参量

offset

可选参量,表示对角线的偏移量,默认值为0。如果值大于0,表示对角线向上的偏移量;如果值小于0,表示对角线向下的偏移量。

axis1

可选参量,用来作为二维子MVar的第一轴的轴,对角线应该从这里开始。默认第一轴为0。

axis2

可选参量,用来作为二维子MVar的第二轴的轴,对角线应该从这里开始。默认第二轴为1。

返回值

新的MVar对象

示例

mx = model.addMVar((5, 5), nameprefix="mx")
diag_m0 = mx.diagonal()
diag_a1 = mx.diagonal(1)
diag_b1 = mx.diagonal(-1)

MVar.getInfo()

摘要

getInfo(infoname)

描述

获取MVar内每个变量的信息值。

参量

infoname

待查询信息的名称。可取值详见 信息章节

返回值

返回一个NumPy的ndarray,维度和MVar对象维度相同,其元素是对应变量信息的取值。

示例

mx = model.addMVar(3)
print(mx.getInfo("LB"))

MVar.item()

摘要

item()

描述

获取0维MVar内的Var变量。如果MVar对象不是0维,触发ValueError异常。

返回值

返回Var对象。

示例

mx = model.addMVar(3)
var = mx[0].item()

MVar.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的MVar对象,其元素保持不变,但形状按参量shape转换。

参量

shape

取值为整数,或者整数元组。表示新MVar对象的形状。

order

可选参量,默认为字符'C',表示兼容C语言,即按行存储;也可设为字符'F',即按列存储,兼容Fortune语言。

返回值

返回一个元素和原MVar对象相同,但形状不同的新MVar对象。

示例

mx = model.addMVar(6)
mx_2x2 = mx.reshape((2, 3))

MVar.setInfo()

摘要

setInfo(infoname, newval)

描述

设置MVar内每个变量的信息值。

参量

infoname

待设置的信息名称。可取值详见 信息章节

newval

待设置新的信息取值。

示例

mx = model.addMVar(3)
mx.setInfo("UB", 9.0)
mx.setInfo(COPT.Info.LB, 0.0)

MVar.sum()

摘要

sum(axis=None)

描述

对MVar里的变量求和,返回一个新的 MLinExpr类 对象。

参量

axis

可选整型参量,默认值为None,即逐个变量求和。否则,按给定的轴求和。

返回值

返回MLinExpr对象,表示对应变量的和。

示例

mx = model.addMVar((3, 5))
sum_all = mx.sum() #返回0维MLinExpr对象
sum_row = mx.sum(axis = 0) #返回1维MLinExpr对象,形状为(5, )

MVar.tolist()

摘要

tolist()

描述

把MVar对象转化为Var对象的一维列表。

返回值

返回包含Var对象的一维列表。

示例

mx = model.addMVar((3, 5))
print(mx.tolist())

MVar.transpose()

摘要

transpose()

描述

生成一个新的MVar对象,它是原MVar对象的转置。

返回值

返回新的MVar对象。

示例

mx = model.addMVar((3, 5))
print(mx.transpose().shape) #其形状为(5, 3)

MVar.ndim

摘要

ndim

描述

MVar对象的维度。

返回值

整型值。

示例

mx = model.addMVar((3, 5))
print(mx.ndim) # ndim = 2

MVar.shape

摘要

shape

描述

MVar对象的形状。

返回值

整型元组。

示例

mx = model.addMVar((3,))
print(mx.shape) # shape = (3, )

MVar.size

摘要

size

描述

MVar对象的Var变量个数。

返回值

整型值。

示例

mx = model.addMVar((3, 4))
print(mx.size) # size = 12

MVar.T

摘要

T

描述

MVar对象的转置。类似于类方法transpose()。

返回值

返回转置后的MVar对象。

示例

mx = model.addMVar((3, 4))
print(mx.T.shape) # shape = (4, 3)

MConstr类

MConstr类是杉数求解器中用于构建多维约束,并支持NumPy的多维数组运算的类。 需要通过模型类的方法addConstrs或者addMConstr来生成。提供了以下成员方法:

MConstr.getInfo()

摘要

getInfo(infoname)

描述

获取MConstr内每个约束的信息值。可取值详见 信息章节

参量

infoname

待获取信息的名称。

返回值

返回一个NumPy的ndarray,维度和MConstr对象维度相同,其元素是对应约束的信息值。

示例

a = np.random.rand(4)
mx = m.addMVar((4, 3), nameprefix="mx")
b = np.random.rand(3)
mc = m.addConstrs(a @ mx <= b)
print(mc.getInfo("pi"))

MConstr.item()

摘要

item()

描述

获取0维MConstr内的约束对象。如果MConstr对象不是0维,触发ValueError异常。

返回值

返回线性约束对象。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc[0].item())

MConstr.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的MConstr对象,其元素保持不变,但形状按参量shape转换。

参量

shape

取值为整数,或者整数元组。表示新MConstr对象的形状。

order

可选参量,默认为字符'C',表示兼容C语言,即按行存储;也可设为字符'F',即按列存储,兼容Fortune语言。

返回值

返回一个元素和原MConstr对象相同,但形状不同的新MConstr对象。

示例

mc = m.addConstrs(a @ mx <= b)
mc_2x2 = mc.reshape((2, 2))

MConstr.setInfo()

摘要

setInfo(infoname, newval)

描述

设置MConstr内每个约束的信息值。

参量

infoname

待设置的信息名称。可取值详见 信息章节

newval

待设置新的信息取值。

示例

mc = model.addConstrs(a @ mx <= b)
mc.setInfo("obj", 9.0)

MConstr.tolist()

摘要

tolist()

描述

把MConstr对象转化为元素为约束的一维列表。

返回值

返回包含Constraint对象的一维列表。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc.tolist())

MConstr.transpose()

摘要

transpose()

描述

生成一个新的MConstr对象,它是原MConstr对象的转置。

返回值

返回转置后的MConstr对象。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc.transpose())

MConstr.ndim

摘要

ndim

描述

MConstr对象的维度。

返回值

整型值。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc.ndim)

MConstr.shape

摘要

shape

描述

MConstr对象的形状。

返回值

整型元组。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc.shape)

MConstr.size

摘要

size

描述

MConstr对象的约束个数。

返回值

整型值。

示例

mc = m.addConstrs(a @ mx <= b)
print(mc.size)

MConstr.T

摘要

T

描述

MConstr对象的转置。类似于类方法transpose()。

返回值

返回转置后的MConstr对象。

示例

A = np.ones([2, 4])
mx = m.addMVar((4, 3), nameprefix="mx")
mc = m.addConstrs(A @ X == 0.0)
print(mc.T.shape) # shape = (3, 2)

MConstrBuilder类

MConstrBuilder类是杉数求解器中多维线性约束的生成器,并支持NumPy的多维数组运算。 需要通过一组 ConstrBuilder类 对象生成,或者 MVar类 对象,MLinExpr类 对象 的比较运算符重载来生成。提供了以下成员方法:

MConstrBuilder()

摘要

MConstrBuilder(args, shape=None)

描述

类构造方法,生成MConstrBuilder对象。

参量

args

单个或者一组 ConstrBuilder类 对象。可以是Python列表,或者NumPy多维数组。

shape

取值为整数,或者整数元组。表示新MConstrBuilder对象的形状。

示例

vars = m.addVars(4)
builders = [x <= 1.0 for x in vars]
mcb = MConstrBuilder(builders, (2, 2))

# 或者通过MVar对象的比较运算符来生成
mx = m.addMVar((3, 2))
mcb = mx >= 1.0

# 它可以作为addConstrs的输入
model.addConstrs(mx >= 1.0)

MQConstrBuilder类

MQConstrBuilder类是杉数求解器中多维二次约束的生成器,并支持NumPy的多维数组运算。 需要通过一组 QConstrBuilder类 对象生成,或者 MQuadExpr类 对象的比较运算符重载来生成。提供了以下成员方法:

MQConstrBuilder()

摘要

MQConstrBuilder(args, shape=None)

描述

类构造方法,生成MQConstrBuilder对象。

参量

args

单个或者一组 QConstrBuilder类 对象。可以是Python列表,或者NumPy多维数组。

shape

取值为整数,或者整数元组。表示新MQConstrBuilder对象的形状。

示例

x = model.addVar()
mqcb = MQConstrBuilder(x * x <= 9.0)

# 或者通过MVar对象的矩阵乘法和MQuadExpr的比较运算符来生成
mx = model.addMVar(3, 3)
mqcb = mx @ mx >= 1.0

# 它可以作为addQConstr的输入
ma = model.addMVar(2)
A = np.full((2,3), 1)
mb = model.addMVar(3)
model.addQConstr(ma @ A @ mb <= 1.0)

MLinExpr类

MLinExpr类是杉数求解器中用于构建多维线性表达式,并支持NumPy的多维数组运算的类。 可以通过类生成方法zeros()来生成初始值为0.0的MLinExpr对象,也可以通过对 MVar类 对象的线性组合来生成。提供了以下成员方法:

MLinExpr.zeros()

摘要

zeros(shape)

描述

这是类生成方法,可以直接调用,无需MLinExpr对象。

参量

shape

取值为整数,或者整数元组。表示新MLinExpr对象的形状。

返回值

新的MLinExpr对象。

示例

mexpr = MLinExpr.zeros((2,3))
x = model.addVar()
mexpr += x

MLinExpr.clear()

摘要

clear()

描述

重置 MLinExpr类 对象的每个元素为0.0。

示例

mexpr = 2.0 * model.addMVar(3)
mexpr.clear()

MLinExpr.clone()

摘要

clone()

描述

深度复制一个 MLinExpr类 对象。

返回值

新的MLinExpr对象

示例

mexpr = 2.0 * model.addMVar(3)
mexpr_copy = mexpr.clone()

MLinExpr.getValue()

摘要

getValue()

描述

获取 MLinExpr类 对象内每个线性表达式的估值。

返回值

返回一个NumPy的ndarray,维度和MLinExpr对象维度相同,其元素是对应表达式的估值。

示例

a = np.random.rand(4)
mx = m.addMVar((4, 3), nameprefix="mx")
mexpr = a @ mx
mc = m.addConstrs(mexpr <= 1.0)
model.solve()
print(mc.getValue())

MLinExpr.item()

摘要

item()

描述

获取0维MLinExpr内的约束对象。如果MLinExpr对象不是0维,触发ValueError异常。

返回值

返回线性约束对象。

示例

mexpr = 2.0 * model.addMVar(3)
print(mexpr[0].item())

MLinExpr.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的MLinExpr对象,其元素保持不变,但形状按参量shape转换。

参量

shape

取值为整数,或者整数元组。表示新MLinExpr对象的形状。

order

可选参量,默认为字符'C',表示兼容C语言,即按行存储;也可设为字符'F',即按列存储,兼容Fortune语言。

返回值

返回一个元素和原MLinExpr对象相同,但形状不同的新MLinExpr对象。

示例

mc = m.addConstrs(a @ mx <= b)
mc_2x2 = mc.reshape((2, 2))

MLinExpr.sum()

摘要

sum(axis=None)

描述

对MLinExpr对象里的变量求和,返回一个新的 MLinExpr类 对象。

参量

axis

可选整型参量,默认值为None,即逐个变量求和。否则,按给定的轴求和。

返回值

返回MLinExpr对象,表示对应线性表达式的和。

示例

mexpr = 2.0 * model.addMVar((3, 5))
sum_all = mexpr.sum() #返回0维MLinExpr对象
sum_row = mexpr.sum(axis = 0) #返回1维MLinExpr对象,形状为(5, )

MLinExpr.tolist()

摘要

tolist()

描述

把MLinExpr对象转化为元素为线性表达式的一维列表。

返回值

返回包含 LinExpr类 的一维列表。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.tolist())

MLinExpr.transpose()

摘要

transpose()

描述

生成一个新的MLinExpr对象,它是原MLinExpr对象的转置。

返回值

返回转置后的MLinExpr对象。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.transpose())

MLinExpr.ndim

摘要

ndim

描述

MLinExpr类 对象的维度。

返回值

整型值。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.ndim)

MLinExpr.shape

摘要

shape

描述

MLinExpr类 对象的形状。

返回值

整型元组。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.shape)

MLinExpr.size

摘要

size

描述

MLinExpr类 对象的元素个数。

返回值

整型值。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.size)

MLinExpr.T

摘要

T

描述

MLinExpr类 对象的转置。类似于类方法transpose()。

返回值

返回转置后的MLinExpr对象。

示例

mexpr = 2.0 * model.addMVar((3, 5))
print(mexpr.T.shape) # 转置后的形状为(5, 3)

MLinExpr.__eq__()

摘要

__eq__()

描述

对运算符==的重载,生成一个 MConstrBuilder类 对象。可以作为 模型类里的 addConstrs 的输入。

返回值

返回 MConstrBuilder类 对象。

示例

model.addConstrs(A @ x == 1.0)

MLinExpr.__ge__()

摘要

__ge__()

描述

对运算符>=的重载,生成一个 MConstrBuilder类 对象。可以作为 模型类里的 addConstrs 的输入。

返回值

返回 MConstrBuilder类 对象。

示例

model.addConstrs(A @ x >= 1.0)

MLinExpr.__le__()

摘要

__le__()

描述

对运算符<=的重载,生成一个 MConstrBuilder类 对象。可以作为 模型类里的 addConstrs 的输入。

返回值

返回 MConstrBuilder类 对象。

示例

model.addConstrs(A @ x <= 1.0)

MQuadExpr类

MQuadExpr类是杉数求解器中用于构建多维二次表达式,并支持NumPy的多维数组运算的类。 可以通过类生成方法zeros()来生成初始值为0.0的MQuadExpr对象,也可以通过对两个 MVar类 对象的(矩阵)相乘来生成。提供了以下成员方法:

MQuadExpr.zeros()

摘要

zeros(shape)

描述

这是类生成方法,可以直接调用,无需MQuadExpr对象。

参量

shape

取值为整数,或者整数元组。表示新MQuadExpr对象的形状。

返回值

新的MQuadExpr对象。

示例

mqx = MQuadExpr.zeros((2,3)) # shape = (2, 3)
x = model.addVar()
mqx += 2.0 * x * x           # broadcast scalar
mqx += model.addMVar(3)      # broadcast MVar of shape (3,)

MQuadExpr.clear()

摘要

clear()

描述

重置 MQuadExpr类 对象的每个元素为0.0。

示例

ma = model.addMVar(3, nameprefix='a')
mb = model.addMVar(3, nameprefix='b')
mqx = ma * mb    # elementwise multiply, shape = (3,)
mqx.clear()
print(mqx)       # result is [0.0, 0.0, 0.0]

MQuadExpr.clone()

摘要

clone()

描述

深度复制一个 MQuadExpr类 对象。

返回值

新的 MQuadExpr类 对象。

示例

mx = model.addMVar((3, 3), nameprefix='mx')
mqx = 2.0 * mx @ mx      # matrix multiply, shape = (3, 3)
mqx_copy = mqx.clone()
mqx_copy.clear()
print(mqx)               # mqx is untouched

MQuadExpr.getValue()

摘要

getValue()

描述

获取 MQuadExpr类 对象内每个二次表达式的估值。

返回值

返回一个NumPy的ndarray,维度和MQuadExpr对象维度相同,其元素是对应表达式的估值。

示例

A = np.eye(3)
mx = m.addMVar(3, nameprefix="mx")
mqx = mx @ A @ mx        # 0-D MQuadExpr, shape = ()
m.addQConstr(mqx <= 9.0)
m.solve()
print(mqx.getValue())

MQuadExpr.item()

摘要

item()

描述

获取0维MQuadExpr内的约束对象。如果MQuadExpr对象不是0维,触发ValueError异常。

返回值

返回二次表达式对象。

示例

x = m.addVar()
mqx = MQuadExpr.zeros(3) + x * x
print(mqx[1].item()) # 返回 QuadExpr(x * x)

MQuadExpr.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的MQuadExpr对象,其元素保持不变,但形状按参量shape转换。

参量

shape

取值为整数,或者整数元组。表示新MQuadExpr对象的形状。

order

可选参量,默认为字符'C',表示兼容C语言,即按行存储;也可设为字符'F',即按列存储,兼容Fortune语言。

返回值

返回一个元素和原MQuadExpr对象相同,但形状不同的新MQuadExpr对象。

示例

mqx = MQuadExpr.zeros(6)
mqx_2x3 = mqx.reshape((2, 3))

MQuadExpr.sum()

摘要

sum(axis=None)

描述

对MQuadExpr对象里的二次表达式求和,返回一个新的 MQuadExpr类 对象。

参量

axis

可选整型参量,默认值为None,即逐个表达式求和。否则按给定的轴求和。

返回值

返回MQuadExpr对象,表示对应二次表达式的和。

示例

ma = model.addMVar((2, 3), nameprefix='ma')
mb = model.addMVar((3, 2), nameprefix='mb')
mqx = ma @ mb
sum_all = mqx.sum()         # 返回0维MQuadExpr对象
sum_row = mqx.sum(axis = 0) # 返回1维MQuadExpr对象,形状为(2,)

MQuadExpr.tolist()

摘要

tolist()

描述

把MQuadExpr对象转化为元素为二次表达式的一维列表。

返回值

返回元素为 QuadExpr类 的一维列表。

示例

print(MQuadExpr.zeros((2,3)).tolist()) # 长度为6的列表

MQuadExpr.transpose()

摘要

transpose()

描述

生成一个新的MQuadExpr对象,它是原MQuadExpr对象的转置。

返回值

返回转置后的MQuadExpr对象。

示例

mqx = MQuadExpr.zeros((2,3))
print(mqx.transpose().shape) # shape = (3, 2)

MQuadExpr.ndim

摘要

ndim

描述

MQuadExpr类 对象的维度。

返回值

整型值。

示例

mqx = MQuadExpr.zeros((2,3))
print(mqx.ndim)  # ndim = 2

MQuadExpr.shape

摘要

shape

描述

MQuadExpr类 对象的形状。

返回值

整型元组。

示例

print(MQuadExpr.zeros((2,3)).shape) # shape = (2, 3)

MQuadExpr.size

摘要

size

描述

MQuadExpr类 对象的元素个数。

返回值

整型值。

示例

mqx = MQuadExpr.zeros((2,3))
print(mqx.size)  # size= 6

MQuadExpr.T

摘要

T

描述

MQuadExpr类 对象的转置。类似于类方法transpose()。

返回值

返回转置后的MQuadExpr对象。

示例

mqx = MQuadExpr.zeros((2,3))
print(mqx.T.shape) # shape = (3, 2)

MQuadExpr.__eq__()

摘要

__eq__()

描述

对运算符==的重载,生成一个 MQConstrBuilder类 对象。可以作为 模型类里的 addQConstr 的输入。

返回值

返回 MQConstrBuilder类 对象。

示例

model.addQConstr(x @ Q @ y == 1.0)

MQuadExpr.__ge__()

摘要

__ge__()

描述

对运算符>=的重载,生成一个 MQConstrBuilder类 对象。可以作为 模型类里的 addQConstr 的输入。

返回值

返回 MQConstrBuilder类 对象。

示例

model.addQConstr(x @ Q @ y >= 1.0)

MQuadExpr.__le__()

摘要

__le__()

描述

对运算符<=的重载,生成一个 MQConstrBuilder类 对象。可以作为 模型类里的 addQConstr 的输入。

返回值

返回 MQConstrBuilder类 对象。

示例

model.addQConstr(x @ Q @ y <= 1.0)

ExprBuilder类

ExprBuilder类是杉数求解器中用于构建线性约束的构建器,提供了以下成员方法:

ExprBuilder()

摘要

ExprBuilder(arg1=0.0, arg2=None)

描述

创建一个 ExprBuilder类 对象。

若参数 arg1 为常数,参数 arg2None,则创建一个 ExprBuilder类 对象,并以参数 arg1 的值初始化; 若参数 arg1Var类 对象或 ExprBuilder类 对象,则参数 arg2 为常数, 参数 arg2 可为 None,此时当作常数1.0,并以参数 arg1arg2 初始化新创建的 ExprBuilder类 对象; 若参数 arg1arg2 为列表对象,则分别表示组成线性表达式 的变量、系数,并初始化新创建的 ExprBuilder类 对象。

参量

arg1

可选参量,默认值为0.0。

arg2

可选参量,默认值为 None

示例

# 创建一个新的ExprBuilder对象,并初始化为:0.0
expr0 = ExprBuilder()
# 创建一个ExprBuilder对象,并初始化为:x + 2*y
expr2 = ExprBuilder([x, y], [1, 2])

ExprBuilder.getSize()

摘要

getSize()

描述

获取表达式构建器中项的个数。

示例

# 获取线性表达式构建器expr中元素的个数
exprsize = expr.getSize()

ExprBuilder.getCoeff()

摘要

getCoeff(idx)

描述

根据变量在表达式构建器中的下标获取其系数。

参量

idx

变量在表达式构建器中的下标。起始为0。

示例

# 获取线性表达式构建器expr第1项的系数
coeff = expr.getCoeff(1)

ExprBuilder.getVar()

摘要

getVar(idx)

描述

根据变量在表达式中构建器的下标获取相应的变量,返回一个 Var类 对象。

参量

idx

变量在表达式构建器中的下标。起始为0。

示例

# 获取线性表达式构建器expr第1项的变量
x = expr.getVar(1)

ExprBuilder.getConstant()

摘要

getConstant()

描述

获取表达式构建器中的常数项。

示例

# 获取线性表达式expr的常数项
constant = expr.getConstant()

ExprBuilder.addTerm()

摘要

addTerm(var, coeff=1.0)

描述

添加新的项到当前表达式构建器中。

参量

var

待添加项的变量。

coeff

待添加项的放大系数。可选参量,默认值为1.0。

示例

# 添加项:2*x 到线性表达式构建器expr中
expr.addTerm(x, 2.0)

ExprBuilder.addExpr()

摘要

addExpr(expr, coeff=1.0)

描述

添加新的表达式构建器到当前表达式构建器中。

参量

expr

待添加表达式构建器。

coeff

待添加表达式构建器的放大系数。可选参量,默认值为1.0。

示例

# 添加线性表达式构建器对象 2*x + 2*y 到线性表达式构建器expr中
expr.addExpr(x + y, 2.0)

ExprBuilder.clone()

摘要

clone()

描述

创建表达式构建器对象的深拷贝。

示例

# 创建线性表达式构建器expr的深拷贝
exprcopy = expr.clone()

ExprBuilder.getExpr()

摘要

getExpr()

描述

创建并获取线性表达式构建器相应的表达式,返回一个 LinExpr类 对象。

示例

# 获取线性表达式构建器exprbuilder相应的表达式
expr = exprbuilder.getExpr()

LinExpr类

LinExpr类是杉数求解器中用于构建线性表达式时变量的相关组合操作,提供了以下成员方法:

LinExpr()

摘要

LinExpr(arg1=0.0, arg2=None)

描述

创建一个 LinExpr类 对象。

若参数 arg1 为常数,参数 arg2None,则创建一个 LinExpr类 对象,并以参数 arg1 的值初始化; 若参数 arg1Var类 对象或 LinExpr类 对象,则参数 arg2 为常数, 参数 arg2 可为 None,此时当作常数1.0,并以参数 arg1arg2 初始化新创建的 LinExpr类 对象; 若参数 arg1 为列表对象,参数 arg2None,则参数 arg1 中的元素为变量、系数对,并以参数 arg1arg2 初始化新创建的 LinExpr类 对象; 对于其它参数情形,则调用成员方法 addTerms 初始化新创建的 LinExpr类 对象。

参量

arg1

可选参量,默认值为0.0。

arg2

可选参量,默认值为 None

示例

# 创建一个新的LinExpr对象,并初始化为:0.0
expr0 = LinExpr()
# 创建一个LinExpr对象,并初始化为:2*x + 3*y
expr1 = LinExpr([(x, 2), (y, 3)])
# 创建一个LinExpr对象,并初始化为:x + 2*y
expr2 = LinExpr([x, y], [1, 2])

LinExpr.setCoeff()

摘要

setCoeff(idx, newval)

描述

根据变量在表达式中的下标设置其系数。

参量

idx

变量在表达式中的下标。起始为0。

newval

变量的新系数。

示例

# 设置线性表达式expr第0项的系数为1.0
expr.setCoeff(0, 1.0)

LinExpr.getCoeff()

摘要

getCoeff(idx)

描述

根据变量在表达式中的下标获取其系数。

参量

idx

变量在表达式中的下标。起始为0。

示例

# 获取线性表达式expr第1项的系数
coeff = expr.getCoeff(1)

LinExpr.getVar()

摘要

getVar(idx)

描述

根据变量在表达式中的下标获取相应的变量,返回一个 Var类 对象。

参量

idx

变量在表达式中的下标。起始为0。

示例

# 获取线性表达式expr第1项的变量
x = expr.getVar(1)

LinExpr.getConstant()

摘要

getConstant()

描述

获取表达式中的常数项。

示例

# 获取线性表达式expr的常数项
constant = expr.getConstant()

LinExpr.getValue()

摘要

getValue()

描述

获取以变量的取值计算出的表达式的值。

示例

# 获取线性表达式expr的当前值
val = expr.getValue()

LinExpr.getSize()

摘要

getSize()

描述

获取表达式中项的个数。

示例

# 获取线性表达式expr中元素的个数
exprsize = expr.getSize()

LinExpr.setConstant()

摘要

setConstant(newval)

描述

设置表达式的常数项。

参量

newval

待设置常数值。

示例

# 设置线性表达式expr的常数项为2.0
expr.setConstant(2.0)

LinExpr.addConstant()

摘要

addConstant(newval)

描述

添加常数到表达式。

参量

newval

待添加常数值。

示例

# 添加常数2.0到线性表达式expr中
expr.addConstant(2.0)

LinExpr.addTerm()

摘要

addTerm(var, coeff=1.0)

描述

添加新的项到当前表达式中。

参量

expr

待添加项的变量。

coeff

待添加项的放大系数。可选参量,默认值为1.0。

示例

# 添加项:x到线性表达式expr中
expr.addTerm(x)

LinExpr.addTerms()

摘要

addTerms(vars, coeffs)

描述

添加单个或多个新项到表达式。

若参数 varsVar类 对象,则参数 coeffs 为常数; 若参数 varsVarArray类 对象或列表对象,则参数 coeffs 为常数或列表对象; 若参数 vars 为 字典对象或 tupledict类 对象,则参数 coeffs 为常数、字典或 tupledict类 对象。

参量

vars

待添加的变量。

coeffs

待添加项的系数。

示例

# 添加项:2*x + 2*y到线性表达式expr中
expr.addTerms([x, y], [2.0, 3.0])

LinExpr.addExpr()

摘要

addExpr(expr, coeff=1.0)

描述

添加新的表达到当前表达式中。

参量

expr

待添加表达式或者表达式构建器对象。

coeff

待添加表达式的放大系数。可选参量,默认值为1.0。

示例

# 添加线性表达式:2*x + 2*y到线性表达式expr中
expr.addExpr(x + y, 2.0)

LinExpr.clone()

摘要

clone()

描述

创建表达式对象的深拷贝。

示例

# 创建线性表达式expr的深拷贝
exprcopy = expr.clone()

LinExpr.reserve()

摘要

reserve(n)

描述

为表达式对象预分配空间。

参量

n

预分配的表达式中项的数目。

示例

# 预分配表达式expr中项的数目为100
expr.reserve(100)

LinExpr.remove()

摘要

remove(item)

描述

从表达式中移除指定项。

若参数 item 为常数,则移除指定下标对应的项;否则参数 itemVar类 对象。

参量

item

常数下标或待移除项相应的变量。

示例

# 从线性表达式expr中移除下标为2相应的项
expr.remove(2)
# 从线性表达式expr中移除变量x相应的项
expr.remove(x)

QuadExpr类

QuadExpr类是杉数求解器中用于构建线性表达式时变量的相关组合操作,提供了以下成员方法:

QuadExpr()

摘要

QuadExpr(expr=0.0)

描述

创建一个 QuadExpr类 对象。

参数 expr 为常数、 Var类 对象、 LinExpr类 对象 或 QuadExpr类 对象。

参量

expr

可选参量,默认值为0.0。

示例

# 创建一个新的QuadExpr对象,并初始化为:0.0
quadexpr0 = QuadExpr()
# 创建一个QuadExpr对象,并初始化为:2*x + 3*y
quadexpr1 = QuadExpr(2*x + 3*y)
# 创建一个QuadExpr对象,并初始化为:x*x + 2*y*z
quadexpr2 = QuadExpr(x*x + 2*y*z)

QuadExpr.setCoeff()

摘要

setCoeff(idx, newval)

描述

设置二次表达式中指定索引值对应的二次项系数。

参量

idx

指定的索引值。起始为0。

newval

变量的新系数。

示例

# 设置二次表达式quadexpr第0项的系数为1.0
quadexpr.setCoeff(0, 1.0)

QuadExpr.getCoeff()

摘要

getCoeff(idx)

描述

根据变量在表达式中的下标获取其系数。

参量

idx

变量在表达式中的下标。起始为0。

示例

# 获取二次表达式quadexpr第1项的系数
coeff = quadexpr.getCoeff(1)

QuadExpr.getVar1()

摘要

getVar1(idx)

描述

获取指定的二次项的第一个变量,返回一个 Var类 对象。

参量

idx

二次项的下标。起始为0。

示例

# 获取第1个二次项的第1个变量
x = expr.getVar1(1)

QuadExpr.getVar2()

摘要

getVar2(idx)

描述

获取指定的二次项的第二个变量,返回一个 Var类 对象。

参量

idx

二次项的下标。起始为0。

示例

# 获取第1个二次项的第2个变量
y = expr.getVar2(1)

QuadExpr.getLinExpr()

摘要

getLinExpr()

描述

获取二次表达式中的线性表达式。

示例

# 获取二次表达式quadexpr中的线性表达式linexpr
linexpr = quadexpr.getLinExpr()

QuadExpr.getConstant()

摘要

getConstant()

描述

获取表达式中的常数项。

示例

# 获取二次表达式quadexpr的常数项
constant = quadexpr.getConstant()

QuadExpr.getValue()

摘要

getValue()

描述

获取以变量的取值计算出的表达式的值。

示例

# 获取二次表达式quadexpr的当前值
val = quadexpr.getValue()

QuadExpr.getSize()

摘要

getSize()

描述

获取表达式中项的个数。

示例

# 获取二次表达式quadexpr中元素的个数
exprsize = quadexpr.getSize()

QuadExpr.setConstant()

摘要

setConstant(newval)

描述

设置表达式的常数项。

参量

newval

待设置常数值。

示例

# 设置二次表达式quadexpr的常数项为2.0
quadexpr.setConstant(2.0)

QuadExpr.addConstant()

摘要

addConstant(newval)

描述

添加常数到表达式。

参量

newval

待添加常数值。

示例

# 添加常数2.0到二次表达式quadexpr中
quadexpr.addConstant(2.0)

QuadExpr.addTerm()

摘要

addTerm(coeff, var1, var2=None)

描述

添加新的项到当前表达式中。

参量

coeff

待添加项的系数。

var1

待添加项的第一个变量。

var2

待添加项的第二个变量。可以为 None,表示添加线性项。

示例

# 添加项:x到二次表达式quadexpr中
quadexpr.addTerm(1.0, x)

QuadExpr.addTerms()

摘要

addTerms(coeffs, vars1, vars2=None)

描述

添加单个或多个新项到表达式。

若参数 vars1Var类 对象,则参数 vars2Var类 对象或 None ,参数 coeffs 为常数; 若参数 vars1VarArray类 对象或列表对象,则参数 vars2VarArray类 对象、列表对象或 None ,参数 coeffs 为常数或列表对象; 若参数 vars1 为字典对象或 tupledict类 对象,则参数 vars2 为字典对象、 tupledict类 对象或 None ,参数 coeffs 为常数、字典或 tupledict类 对象。

参量

coeffs

待添加项的系数。

vars1

待添加项的第一个变量。

vars2

待添加项的第二个变量。可以取值 None,表示添加线性项。

示例

# 添加项:2*x + 3y + 2*x*x + 3*x*y 到二次表达式quadexpr中
# 注意:addTerms不支持混合线性项和二次项
quadexpr.addTerms([2.0, 3.0], [x, y])
quadexpr.addTerms([2.0, 3.0], [x, x], [x, y])

QuadExpr.addLinExpr()

摘要

addLinExpr(expr, mult=1.0)

描述

添加新的表达到当前表达式中。

参量

expr

待添加表达式或者表达式构建器对象。

mult

待添加表达式的放大系数。可选参量,默认值为1.0。

示例

# 添加线性表达式:2*x + 2*y到二次表达式quadexpr中
quadexpr.addLinExpr(x + y, 2.0)

QuadExpr.addQuadExpr()

摘要

addQuadExpr(expr, mult=1.0)

描述

添加新的表达到当前表达式中。

参量

expr

待添加表达式或者表达式构建器对象。

mult

待添加表达式的放大系数。可选参量,默认值为1.0。

示例

# 添加二次表达式:x*x + 2*y到二次表达式quadexpr中
quadexpr.addQuadExpr(x*x + 2*y, 2.0)

QuadExpr.clone()

摘要

clone()

描述

创建表达式对象的深拷贝。

示例

# 创建二次表达式quadexpr的深拷贝
exprcopy = quadexpr.clone()

QuadExpr.reserve()

摘要

reserve(n)

描述

为表达式对象预分配空间。

参量

n

预分配的表达式中项的数目。

示例

# 预分配表达式expr中项的数目为100
expr.reserve(100)

QuadExpr.remove()

摘要

remove(item)

描述

从表达式中移除指定项。

若参数 item 为常数,则移除指定下标对应的项;否则参数 itemVar类 对象。

参量

item

常数下标或待移除项相应的变量。

示例

# 从二次表达式quadexpr中移除下标为2相应的项
quadexpr.remove(2)
# 从二次表达式quadexpr中移除变量x相应的项
quadexpr.remove(x)

PsdExpr类

PsdExpr类是杉数求解器中用于构建半定表达式时变量的相关组合操作,提供了以下成员方法:

PsdExpr()

摘要

PsdExpr(expr=0.0)

描述

创建一个 PsdExpr类 对象。

参量

expr

可选参量,默认值为0.0。可取值为常数、Var类 对象、 LinExpr类 对象和 PsdExpr类 对象。

示例

# 创建一个新的PsdExpr对象,并初始化为:0.0
expr0 = PsdExpr()
# 创建一个PsdExpr对象,并初始化为:2*x + 3*y
expr1 = PsdExpr(2*x + 3*y)

PsdExpr.setCoeff()

摘要

setCoeff(idx, mat)

描述

根据半定变量在表达式中的下标设置其对称矩阵系数。

参量

idx

半定变量在表达式中的下标。起始为0。

mat

半定变量的新对称矩阵系数。

示例

# 设置半定表达式expr第0项的系数为对称矩阵mat
expr.setCoeff(0, mat)

PsdExpr.getCoeff()

摘要

getCoeff(idx)

描述

根据半定变量在表达式中的下标获取其对称矩阵系数。

参量

idx

半定变量在表达式中的下标。起始为0。

示例

# 获取半定表达式expr第1项的对称矩阵系数
mat = expr.getCoeff(1)

PsdExpr.getPsdVar()

摘要

getPsdVar(idx)

描述

根据半定变量在表达式中的下标获取相应的半定变量,返回一个 PsdVar类 对象。

参量

idx

半定变量在表达式中的下标。起始为0。

示例

# 获取半定表达式expr第1项的半定变量
x = expr.getPsdVar(1)

PsdExpr.getLinExpr()

摘要

getLinExpr()

描述

获取表达式中的线性表达式。

示例

# 获取半定表达式expr的线性表达式
linexpr = expr.getLinExpr()

PsdExpr.getConstant()

摘要

getConstant()

描述

获取表达式中的常数项。

示例

# 获取半定表达式expr的常数项
constant = expr.getConstant()

PsdExpr.getValue()

摘要

getValue()

描述

获取以半定变量和变量的取值计算出的表达式的值。

示例

# 获取半定表达式expr的当前值
val = expr.getValue()

PsdExpr.getSize()

摘要

getSize()

描述

获取半定表达式中项的个数。

示例

# 获取半定表达式expr中元素的个数
exprsize = expr.getSize()

PsdExpr.setConstant()

摘要

setConstant(newval)

描述

设置半定表达式的常数项。

参量

newval

待设置常数值。

示例

# 设置半定表达式expr的常数项为2.0
expr.setConstant(2.0)

PsdExpr.addConstant()

摘要

addConstant(newval)

描述

添加常数到半定表达式。

参量

newval

待添加常数值。

示例

# 添加常数2.0到半定表达式expr中
expr.addConstant(2.0)

PsdExpr.addTerm()

摘要

addTerm(var, mat)

描述

添加新的半定项到当前半定表达式中。

参量

var

待添加半定项的半定变量。

mat

待添加半定项的对称矩阵。

示例

# 添加半定项 C1 * X到半定表达式expr中
expr.addTerm(X, C1)

PsdExpr.addTerms()

摘要

addTerms(vars, mats)

描述

添加单个或多个新半定项到半定表达式。

若参数 varsPsdVar类 对象,则参数 matsSymMatrix类 对象; 若参数 varsPsdVarArray类 对象或列表对象,则参数 matsSymMatrixArray类 对象或列表对象;

参量

vars

待添加半定项的半定变量。

mats

待添加半定项的对称矩阵。

示例

# 添加项:C1 * X1 + C2 * X2到半定表达式expr中
expr.addTerms([X1, X2], [C1, C2])

PsdExpr.addLinExpr()

摘要

addLinExpr(expr, mult=1.0)

描述

添加新的线性表达式到当前半定表达式中。

参量

expr

待添加线性表达式或者线性表达式构建器对象。

mult

待添加线性表达式的放大系数。可选参量,默认值为1.0。

示例

# 添加线性表达式:2*x + 2*y到半定表达式expr中
expr.addLinExpr(x + y, 2.0)

PsdExpr.addPsdExpr()

摘要

addPsdExpr(expr, mult=1.0)

描述

添加新的半定表达式到当前半定表达式中。

参量

expr

待添加半定表达式。

mult

待添加半定表达式的放大系数。可选参量,默认值为1.0。

示例

# 添加半定表达式:C * X到半定表达式expr中
expr.addPsdExpr(C*X)

PsdExpr.clone()

摘要

clone()

描述

创建表达式对象的深拷贝。

示例

# 创建半定表达式expr的深拷贝
exprcopy = expr.clone()

PsdExpr.reserve()

摘要

reserve(n)

描述

为半定表达式对象预分配空间。

参量

n

预分配的半定表达式中项的数目。

示例

# 预分配半定表达式expr中项的数目为100
expr.reserve(100)

PsdExpr.remove()

摘要

remove(item)

描述

从半定表达式中移除指定项。

若参数 item 为常数,则移除指定下标对应的项;否则参数 itemPsdVar类 对象。

参量

item

常数下标或待移除项相应的半定变量。

示例

# 从半定表达式expr中移除下标为2相应的项
expr.remove(2)
# 从半定表达式expr中移除半定变量x相应的项
expr.remove(x)

LmiExpr类

LmiExpr类是杉数求解器中用于构建LMI约束表达式时变量的相关组合操作,提供了以下成员方法:

LmiExpr()

摘要

LmiExpr(arg1=None, arg2=None)

描述

创建一个 LmiExpr类 对象。

参量

arg1 默认值为 None ,可取值为: Var类 对象,或 SymMatrix类 对象。

若参数 arg1Var类 对象,则参数 arg2SymMatrix类 对象。

LmiExpr.setCoeff()

摘要

setCoeff(idx, mat)

描述

设置LMI表达式中指定索引 idx 对应项的系数矩阵。

参量

idx

指定的索引值。起始为0。

mat

待设置变量的新系数对称矩阵,需为 SymMatrix类 类对象。

示例

# 设置LMI表达式expr第0项的系数为对称矩阵mat
expr.setCoeff(0, mat)

LmiExpr.getCoeff()

摘要

getCoeff(idx)

描述

获取LMI表达式中指定索引 idx 对应项的系数矩阵。

参量

idx

变量在表达式中的下标。起始为0。

示例

# 获取LMI表达式expr第1项的对称矩阵系数
mat = expr.getCoeff(1)

LmiExpr.getVar()

摘要

getVar(idx)

描述

获取LMI表达式中指定索引 idx 对应项中的变量。

参量

idx

指定的索引值。起始为0。

示例

# 获取LMI表达式expr第1项的变量
mat = expr.getVar(1)

LmiExpr.getConstant()

摘要

getConstant()

描述

获取LMI表达式中的常数项对称矩阵。

示例

# 获取LMI表达式expr的常数项对称矩阵
constant = expr.getConstant()

LmiExpr.getSize()

摘要

getSize()

描述

获取LMI表达式中的项数。

示例

# 获取表达式expr中项的个数
val = expr.getSize()

LmiExpr.setConstant()

摘要

setConstant(mat)

描述

设置LMI表达式的常数项对称矩阵。

参量

mat

常数项对应的对称矩阵,需为 SymMatrix类 对象。

示例

# 设置LMI表达式expr的常数项为对称矩阵D1
expr.setConstant(D1)

LmiExpr.addConstant()

摘要

addConstant(mat)

描述

将对称矩阵添加到LMI表达式中的常数项中。

参量

mat

加到常数项的对称矩阵对象。

示例

# 将对称矩阵D2添加到LMI表达式expr的常数项中
expr.addConstant(D2)

LmiExpr.addTerm()

摘要

addTerm(var, mat)

描述

向LMI表达式中添加一个新项。

参量

var

新项中的变量。

mat

新项中作为变量系数的对称矩阵,需为 SymMatrix类 类对象。

示例

# 添加项 x * C1 到LMI表达式expr中
expr.addTerm(x, C1)

LmiExpr.addTerms()

摘要

addTerms(vars, mats)

描述

向LMI表达式中添加多个新项。

若参数 varsVar类 对象,则参数 matsSymMatrix类 对象; 若参数 varsVarArray类 对象或列表对象,则参数 matsSymMatrixArray类 对象或列表对象;

参量

vars

待添加新项的变量数组。

mats

待添加新项的对称矩阵数组。

示例

# 添加项:x1 * C1 + x2 * C2到LMI表达式expr中
expr.addTerms([x1, x2], [C1, C2])

LmiExpr.addLmiExpr()

摘要

addLmiExpr(expr, mult=1.0)

描述

向当前的LMI表达式中,再添加一个新的LMI表达式。

参量

expr

待添加的LMI表达式。

mult

可选的系数倍数,为常数,默认值为1.0。

示例

# 添加半定表达式:2 * x * C到半定表达式expr中
expr.addLmiExpr(x * C, 2.0)

LmiExpr.clone()

摘要

clone()

描述

创建LMI表达式对象的深拷贝。

示例

# 创建LMI表达式expr的深拷贝
exprcopy = expr.clone()

LmiExpr.reserve()

摘要

reserve(n)

描述

为LMI表达式对象预分配空间。

参量

n

预分配的LMI表达式中项的数目。

示例

# 预分配LMI表达式expr中项的数目为100
expr.reserve(100)

LmiExpr.remove()

摘要

remove(item)

描述

从LMI表达式中移除指定项。

若参数 item 为常数,则移除指定下标对应的项;否则参数 itemVar类 对象。

参量

item

常数下标或待移除项相应的变量。

示例

# 从LMI表达式expr中移除下标为2相应的项
expr.remove(2)
# 从LMI表达式expr中移除变量x相应的项
expr.remove(x)

CallbackBase 类

CallbackBase类是对杉数求解器COPT的Callback相关操作的封装。CallbackBase是一个抽象类,用户需要通过实现函数 CallbackBase.callback() 来创建一个实例,该实例会作为参数传入 Model.setCallback() 。CallbackBase类提供以下可以被继承的成员方法:

CallbackBase.where()

摘要

where()

描述

获取回调函数可能的触发条件。

返回值

返回一个整数值。

CallbackBase.callback()

摘要

callback()

描述

回调函数,为纯虚函数。用户覆盖实现求解进程中需要获取的信息或需执行的操作。

示例

class CoptCallback(CallbackBase):
    def __init__(self):
        super().__init__()
    def callback(self):
        # Get the objective value when finding a feasible MIP solution
        if self.where() == COPT.CBCONTEXT_MIPSOL:
            db = self.getInfo(COPT.CBInfo.MipCandObj)

CallbackBase.interrupt()

摘要

interrupt()

描述

中断回调中的求解进程。

CallbackBase.addUserCut()

摘要

addUserCut(lhs, sense = None, rhs = None)

描述

向模型中添加一个割平面。

参量

lhs

割平面约束的左端项。

可取值为 Var类 对象, LinExpr类 对象,或者约束构建器( ConstrBuilder类 对象)。

sense

割平面的约束类型。

可选参量,默认为 None 。可取值为:LESS_EQUAL, GREATER_EQUAL, EQUALFREE

通过 CallbackBase 类 添加的割平面,仅支持单边约束。

rhs

割平面约束的右端项。

可选参量,默认为 None 。 可取值为常数、 Var类 对象,或者 LinExpr类 对象。

示例

self.addUserCut(x+y <= 1)

CallbackBase.addUserCuts()

摘要

addUserCuts(generator)

描述

向模型中批量添加多个割平面。

参量

generator

一组割平面生成器。

可取值为一组线性约束构建器 ConstrBuilderArray类 对象,或多维线性约束生成器 MConstrBuilder类 对象。

示例

self.addUserCuts(x[i]+y[i] <= 1 for i in range(10))

CallbackBase.addLazyConstr()

摘要

addLazyConstr(lhs, sense = None, rhs = None)

描述

向模型中添加一个惰性约束。

参量

lhs

惰性约束的左端项。

可取值为 Var类 对象, LinExpr类 对象,或者约束构建器( ConstrBuilder类 对象)。

sense

惰性约束的约束类型。

可选参量,默认为 None 。可取值为:LESS_EQUAL, GREATER_EQUAL, EQUALFREE

通过 CallbackBase 类 添加的惰性约束,仅支持单边约束。

rhs

惰性约束的右端项。

可选参量,默认为 None 。 可取值为常数、 Var类 对象,或者 LinExpr类 对象。

示例

self.addLazyConstr(x+y <= 1)

CallbackBase.addLazyConstrs()

摘要

addLazyConstrs(generator)

描述

向模型中批量添加多个惰性约束。

参量

generator

一组惰性约束生成器。

可取值为一组线性约束构建器 ConstrBuilderArray类 对象,或多维线性约束生成器 MConstrBuilder类 对象。

示例

self.addLazyConstrs(x[i]+y[i] <= 1 for i in range(10))

CallbackBase.getInfo()

摘要

getInfo(cbinfo)

描述

在MIP求解过程中,根据回调触发条件,获取指定的模型信息值。

参量

cbinfo

指定的信息名称。可取值详见 回调信息

返回值

返回一个常数(整数型或双精度浮点型)。

示例

db = self.getInfo(COPT.CBInfo.BestBnd)

CallbackBase.getRelaxSol()

摘要

getRelaxSol(vars)

描述

在MIP求解过程中,获取当前节点线性松弛解中指定变量的值。

注意:此方法仅适用于 CallbackBase.where() == COPT.CBCONTEXT_MIPRELAX (即找到LP线性松弛解时)。

参量

vars

指定的变量。

返回值

若参数 argsVar类 对象,则返回指定变量的信息值常数;

若参数 args 为列表或 VarArray类 对象,则返回指定变量的信息值组成的一个列表对象;

若参数 args 为字典或 tupledict类 对象,则返回 tupledict类 对象(键为指定变量的下标,值为指定变量的信息值);

若参数 argsNone, 则返回全部变量当前线性松弛解的信息值。

示例

vals = self.getRelaxSol(vars)

CallbackBase.getIncumbent()

摘要

getIncumbent(vars)

描述

在MIP求解过程中,获取当前最优可行解中指定变量的值。

参量

vars

指定的变量。

返回值

若参数 argsVar类 对象,则返回指定变量的信息值常数;

若参数 args 为列表或 VarArray类 对象,则返回指定变量的信息值组成的一个列表对象;

若参数 args 为字典或 tupledict类 对象,则返回 tupledict类 对象(键为指定变量的下标,值为指定变量的信息值);

若参数 argsNone, 则返回全部变量当前最优可行解的信息值。

示例

vals = self.getIncumbent(vars)

CallbackBase.getSolution()

摘要

getSolution(vars)

描述

在MIP求解过程中,获取当前可行解中指定变量的值。

注意:此方法仅适用于 CallbackBase.where() == COPT.CBCONTEXT_MIPSOL (即找到MIP可行解时)。

参量

vars

指定的变量。

返回值

若参数 argsVar类 对象,则返回指定变量的信息值常数;

若参数 args 为列表或 VarArray类 对象,则返回指定变量的信息值组成的一个列表对象;

若参数 args 为字典或 tupledict类 对象,则返回 tupledict类 对象(键为指定变量的下标,值为指定变量的信息值);

若参数 argsNone, 则返回全部变量当前可行解的信息值。

示例

vals = self.getSolution(vars)

CallbackBase.setSolution()

摘要

setSolution(vars, vals)

描述

在MIP求解过程中,为指定变量设置自定义的可行解,(可以是用户通过任意方式找到的可行解,例如通过启发式算法)。

若参数 varsVar类 对象,则参数 vals 为常量;

若参数 vars 为字典或 tupledict类 对象, 则参数 vals 可为常量、字典或 tupledict类 对象;

若参数 vars 为列表或 VarArray类 对象, 则参数 vals 可为常量或列表对象。

参量

vars

指定的变量。

vals

自定义解的值。

示例

self.setSolution(x, 1)

CallbackBase.loadSolution()

摘要

loadSolution()

描述

将当前自定义的解加载入模型中。

注意:当前仅支持完整的自定义解。

示例

self.loadSolution()

GenConstrX类

Model 类中,通过 addGenConstrXXX (如:addGenConstrMax )添加的约束,会返回 一个 GenConstrX 对象。

GenConstrX.getAttr()

摘要

getAttr(attrname)

描述

获取 GenConstrX 类对象的属性值,支持获取 GenConstrX 类对象的类型和名称。

示例

# Get the name of con_max
con_max.getAttr("name")
# Get the type of con_max
con_max.getAttr("type")

GenConstrX.setAttr()

摘要

setAttr(attrname)

描述

设置 GenConstrX 类对象的属性值,支持设置GenConstrX类对象的名称。

示例

# Set the name of con_max
con_max.setAttr("name")

CoptError类

CoptError类是杉数求解器的错误处理相关操作的封装。当方法调用对应的杉数求解器底层接口发生错误时, 则抛出CoptError类的异常,提供了以下属性值访问相应的错误信息:

  • CoptError.retcode

    错误值代码。

  • CoptError.message

    错误值信息。

辅助函数与工具类

辅助函数与工具类基于Python的基本数据类型进行封装,提供了易用的数据类型,便于快速构建复杂的优化模型。 本节将阐述其功能与使用方法。

辅助函数

multidict()

摘要

multidict(data)

描述

将输入的字典对象拆分为键与多个字典对象并返回。

参量

data

待拆分字典对象,该字典对象中每个键映射 \(n\) 个值。

示例

keys, dict1, dict2 = multidict({
  "hello": [0, 1],
  "world": [2, 3]})

quicksum()

摘要

quicksum(data)

描述

快速构建表达式,返回一个 LinExpr类 对象。

参量

data

生成表达式待加项。

示例

expr = quicksum(m.getVars())

tuplelist类

tuplelist类是基于Python列表类的封装,提供了以下成员方法:

tuplelist()

摘要

tuplelist(list)

描述

创建并返回一个 tuplelist类 对象。

参量

list

Python列表对象。

示例

tl = tuplelist([(0, 1), (1, 2)])
tl = tuplelist([('a', 'b'), ('b', 'c')])

tuplelist.add()

摘要

add(item)

描述

tuplelist类 对象中添加项。

参量

item

待添加项,可取值为Python元组对象。

示例

tl = tuplelist([(0, 1), (1, 2)])
tl.add((2, 3))

tuplelist.select()

摘要

select(pattern)

描述

根据指定的模式筛选得到符合条件的项,返回一个 tuplelist类 对象。

参量

pattern

指定的匹配模式。

示例

tl = tuplelist([(0, 1), (0, 2), (1, 2)])
tl.select(0, '*')

tupledict类

tupledict类是基于Python字典类的封装,提供了以下成员方法:

tupledict()

摘要

tupledict(args, kwargs)

描述

创建并返回一个 tupledict类 对象。

参量

args

位置参量。

kwargs

命名参量。

示例

d = tupledict([(0, "hello"), (1, "world")])

tupledict.select()

摘要

select(pattern)

描述

根据指定的模式筛选得到符合条件的项,返回一个 tupledict类 对象。

参量

pattern

指定的匹配模式。

示例

d = tupledict([(0, "hello"), (1, "world")])
d.select()

tupledict.sum()

摘要

sum(pattern)

描述

根据指定的模式筛选累加项,返回一个 LinExpr类 对象。

参量

pattern

指定的匹配模式。

示例

expr = x.sum()

tupledict.prod()

摘要

prod(coeff, pattern)

描述

根据指定的模式筛选,并与乘积系数累乘项,返回一个 LinExpr类 对象。

参量

coeff

乘积系数。可取值为字典或 tupledict类 对象。

pattern

指定的匹配模式。

示例

coeff = dict([(1, 0.1), (2, 0.2)])
expr  = x.prod(coeff)

ProbBuffer类

ProbBuffer类是字符流缓冲区的封装,提供了以下成员方法:

ProbBuffer()

摘要

ProbBuffer(buff)

描述

创建并返回一个 ProbBuffer类 对象。

参量

buff

缓冲区大小,默认为 None,即缓冲区大小为0。

示例

# 创建大小为100的字符流缓冲区
buff = ProbBuffer(100)

ProbBuffer.getData()

摘要

getData()

描述

获取字符流缓冲区中的内容。

示例

# 打印字符流缓冲区buff中的内容
print(buff.getData())

ProbBuffer.getSize()

摘要

getSize()

描述

获取字符流缓冲区的大小。

示例

# 获取字符流缓冲区buff的大小
print(buff.getSize())

ProbBuffer.resize()

摘要

resize(sz)

描述

调整字符流缓冲区的大小。

参量

sz

缓冲区新的大小。

示例

# 调整字符流缓冲区buff的大小
buff.resize(100)