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.objval 和 Model.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()

摘要

addMVar(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类对象或 MConstr类对象；

添加一个半定约束到模型中，返回 PsdConstraint类对象或 MPsdConstr类对象；

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

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

若添加线性约束，则参数 lhs 可取值为 Var类对象、 LinExpr类、 ConstrBuilder类对象或 MConstrBuilder类对象。

若添加半定约束，则参数 lhs 可取值为 PsdExpr类对象、 PsdConstrBuilder类对象或 MPsdConstrBuilder类对象。

若添加Indicator约束，则参数 lhs 为 GenConstrBuilder类对象，并忽略其它参数；

若添加LMI约束，则参数 lhs 为 LmiExpr类对象。

参量

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")

描述

添加一组线性约束、半定约束，或一组Indicator约束到模型中。

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

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

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

若参数 generator 为Indicator约束表达式生成器，则返回一个 GenConstrArray类对象。

参量

generator

整数或（矩阵）表达式生成器，或Indicator约束表达式生成器。

nameprefix

线性约束或Indicator约束的名称前缀。可选参量，默认为 "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类对象。

若参数 sostype 为 SOSBuilder类对象，则参数 vars 和参数 weights 的取值将被忽略；若参数 sostype 为SOS约束类型，可取值为 SOS约束类型，则参数 vars 表示SOS约束的变量，可取值为 VarArray类对象、列表、字典或 tupledict类对象；若参数 weights 为 None ，则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, type=COPT.INDICATOR_IF, name="")

描述

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

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

参量

binvar

Indicator变量。

binval

Indicator变量的取值，可取值为 True 或 False 。

lhs

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

sense

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

rhs

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

type

Indicator约束的类型。可选参量，默认为 COPT.INDICATOR_IF 。可取值详见 Indicator约束类型。

name

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

示例

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

Model.addGenConstrIndicators()

摘要

addGenConstrIndicators(builders, nameprefix="")

描述

添加一组Indicator约束到模型中，并返回 GenConstrArray类对象。

参量

builders

一组Indicator约束构建器。可取值为 GenConstrBuilderArray类对象，或者是由 GenConstrBuilder类对象构成的字典或列表。

nameprefix

Indicator约束的名称前缀。可选参量，默认为 "" ，由求解器自动生成。

Model.addConeByDim()

摘要

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

描述

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

参量

dim

二阶锥约束的维度。

ctype

二阶锥约束的类型。

vtype

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

nameprefix

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

示例

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

Model.addExpConeByDim()

摘要

addExpConeByDim(ctype, vtype, nameprefix="ExpConeV")

描述

添加一个指数锥约束到模型中，并返回添加的 ExpCone类对象。

参量

ctype

指数锥约束的类型。

vtype

指数锥约束中变量的类型。

nameprefix

指数锥约束中变量名称的前缀。可选取值，默认为 "ExpConeV"。

示例

# 添加一个原始指数锥
m.addExpConeByDim(COPT.EXPCONE_PRIMAL, None)

Model.addCone()

摘要

addCone(vars, ctype)

描述

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

若参数 vars 为 ConeBuilder类对象，则参数 ctype 的值将被忽略；

若参数 vars 为变量，可取值为 VarArray类对象、列表、字典或 tupledict类对象，参数 ctype 表示二阶锥的类型，必须被显式指定且不可为空。

参量

vars

构成二阶锥约束的变量。

ctype

二阶锥约束的类型。可取值详见二阶锥约束类型。

示例

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

Model.addCones()

摘要

addCones(vars, ctype=None)

描述

添加一组二阶锥约束。

若参数 vars 为 ConeBuilder类对象或 ConeBuilderArray类对象，则参数 ctype 的值将被忽略；

若参数 vars 为 MVar类，则参数 ctype 表示二阶锥的类型，必须被显式指定且不可为空。

参量

vars

构成二阶锥约束的变量。

ctype

二阶锥约束的类型。可取值详见二阶锥约束类型。

Model.addExpCones()

摘要

addExpCones(vars, ctype)

描述

添加一组由指定变量构成指数锥约束。

若参数 vars 为 ExpConeBuilder类对象，则参数 ctype 的值将被忽略；若参数 vars 为 MVar类，参数 ctype 表示指数锥约束的类型，需要被显式指定。

参量

vars

构成指数锥约束的一组变量。

ctype

指数锥约束的类型。可取值请参考：指数锥约束类型。

Model.addAffineCone()

摘要

addAffineCone(exprs, ctype=None, name="")

描述

添加一个仿射锥到模型中。

若参数 exprs 为 AffineConeBuilder类对象，则参数 ctype 的值将被忽略；

若参数 exprs 为 MLinExpr类对象或 MPsdExpr类对象，参数 ctype 表示仿射锥的类型，必须被显式指定且不可为空。

参量

exprs

仿射锥生成器或构成仿射锥的多维数组表达式。

ctype

仿射锥的类型。可取值详见二阶锥约束类型或指数锥约束类型。

示例

# 添加由Ax+b和c^Tx+d构成的标准二阶仿射锥
A = np.array([[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]])
b = 10
c = np.array([1, -1, 2])
d = 5
x = model.addMVar(3)
model.addAffineCone(cp.vstack(c @ x + d, A @ x + b), ctype=COPT.CONE_QUAD)

Model.addAffineCones()

摘要

addAffineCones(exprs, ctype=None, nameprefix="AffineConV")

描述

添加一组仿射锥到模型中。

若参数 exprs 为 AffineConeBuilder类对象或 AffineConeBuilderArray类对象，则参数 ctype 的值将被忽略；

若参数 exprs 为 MLinExpr类对象或 MPsdExpr类对象，参数 ctype 表示仿射锥的类型，必须被显式指定且不可为空。

参量

exprs

仿射锥生成器或构成仿射锥的多维数组表达式。

ctype

仿射锥的类型。可取值详见二阶锥约束类型或指数锥约束类型。

Model.addQConstr()

摘要

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

描述

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

若添加线性约束，则参数 lhs 可取值为 Var类对象、 LinExpr类对象或 ConstrBuilder类对象；若添加二次约束，则参数 lhs 为 QConstrBuilder类对象，或者 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 或 MVar 类对象。

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 或 MVar 类对象。

vars

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

constant

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

name

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

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrAbs()

摘要

addGenConstrAbs(resvar, argvar, name="")

描述

添加⼀条形如 \(cy+d=|ax+b|\) 的约束到模型中。

参量

resvar

\(cy+d\) ，可取值为 Var 类、 MVar 类、 LinExpr 类或 MLinExpr 对象。

argvar

\(ax+b\) ，可取值为 Var 类、 MVar 类、 LinExpr 类或 MLinExpr 对象。

name

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

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrAnd()

摘要

addGenConstrAnd(resvar, vars, name="")

描述

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

参量

resvar

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

vars

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

name

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

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrOr()

摘要

addGenConstrOr(resvar, vars, name="")

描述

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

参量

resvar

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

argvar

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

name

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

返回值

返回一个 GenConstrX 类对象。

Model.addGenConstrPWL()

摘要

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

描述

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

(51)\[\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 类对象或 MVar 类对象。

yvar

等式左端项 y ，可取值为 Var / MVar 类或 LinExpr / MLinExpr 类对象。

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类对象。

注意：该如果 expr 是 LinExpr类对象，则更新目标函数中的线性项；如果是 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)

描述

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

若参数 constrs 为 None，则返回全部线性约束相应构建器组成的一个 ConstrBuilderArray类对象；若参数 constrs 为 Constraint类对象，则返回指定约束相应的 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约束构建器。

若参数 soss 为 None，则返回全部SOS约束相应构建器组成的一个 SOSBuilderArray类对象；若参数 soss 为 SOS类对象，则返回指定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.getGenConstr()

摘要

getGenConstr(idx)

描述

获取模型中指定下标的Indicator约束，返回一个 GenConstr类对象。

参量

idx

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

示例

# 获取模型中下标为0的Indicator约束
genx = m.getGenConstr(0)

Model.getGenConstrByName()

摘要

getGenConstrByName(name)

描述

获取指定名称的Indicator约束，返回一个 GenConstr类对象。

参量

name

Indicator约束的名称。

示例

# 获取名称为"r"的Indicator约束
r = m.getGenConstrByName("r")

Model.getGenConstrs()

摘要

getGenConstrs()

描述

获取模型中的全部Indicator约束，返回一个 GenConstrArray类对象。

示例

# 获取模型中的全部Indicator约束
cons = m.getGenConstrs()

Model.getGenConstrIndicators()

摘要

getGenConstrIndicators(genconstrs=None)

描述

获取模型中指定Indicator约束的约束构建器，默认获取全部的Indicator约束。返回 GenConstrBuilder类对象或 GenConstrBuilderArray类对象。

示例

# 获取模型中全部Indicator约束的约束构建器
cons = m.getGenConstrIndicators()

Model.getCone()

摘要

getCone(idx)

描述

获取模型中指定序号的二阶锥约束，返回一个 Cone类对象。

参量

idx

指定的序号。起始下标从0开始。

示例

# 获取模型中序号为1的二阶锥约束
cones = m.getCone(1)

Model.getExpCone()

摘要

getExpCone(idx)

描述

获取模型中指定序号的指数锥约束，返回一个 ExpCone类对象。

参量

idx

指定的序号。起始下标从0开始。

示例

# 获取模型中序号为1的指数锥约束
cones = m.getExpCone(1)

Model.getAffineCone()

摘要

getAffineCone(idx)

描述

获取模型中指定序号的仿射锥约束，返回一个 AffineCone类对象。

参量

idx

指定的序号。起始下标从0开始。

示例

# 获取模型中序号为1的仿射锥约束
cones = m.getAffineCone(1)

Model.getAffineConeByName()

摘要

getAffineConeByName(name)

描述

获取模型中指定名称的仿射锥约束，返回一个 AffineCone类对象。

参量

name

指定的名称。

示例

# 获取模型中名称为"afcone"的仿射锥约束
cones = m.getAffineConeByName("afcone")

Model.getCones()

摘要

getCones()

描述

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

示例

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

Model.getExpCones()

摘要

getExpCones()

描述

获取模型中的全部指数锥约束，返回一个 ExpConeArray类对象。

示例

# 获取模型中的全部指数锥约束
cones = m.getExpCones()

Model.getAffineCones()

摘要

getAffineCones()

描述

获取模型中的全部仿射锥约束，返回一个 AffineConeArray类对象。

示例

# 获取模型中的全部仿射锥约束
cones = m.getAffineCones()

Model.getConeBuilders()

摘要

getConeBuilders(cones=None)

描述

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

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

参量

cones

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

示例

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

Model.getExpConeBuilders()

摘要

getExpConeBuilders(cones=None)

描述

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

若参数 cones 为 None，则返回全部指数锥约束相应构建器组成的一个 ExpConeBuilderArray类对象；若参数 cones 为 ExpCone类对象，则返回指定指数锥约束相应的 ExpConeBuilder类对象；若参数 cones 为列表或 ExpConeArray类对象，则返回指定指数锥约束相应构建器组成的一个 ExpConeBuilderArray类对象。

参量

cones

指定的指数锥约束。可选参量，默认为 None 。

示例

# 获取模型中所有指数锥约束相应的构建器
cones = m.getExpConeBuilders()

Model.getAffineConeBuilders()

摘要

getAffineConeBuilder(cones=None)

描述

获取指定仿射锥约束相应的仿射锥约束构建器。

若参数 cones 为 None，则返回全部仿射锥约束相应构建器组成的一个 AffineConeBuilderArray类对象；若参数 cones 为 AffineCone类对象，则返回指定仿射锥约束相应的 AffineConeBuilder类对象；若参数 cones 为列表或 AffineConeArray类对象，则返回指定仿射锥约束相应构建器组成的一个 AffineConeBuilderArray类对象。

参量

cones

指定的仿射锥约束。可选参量，默认为 None 。

示例

# 获取模型中的全部仿射锥约束
cones = m.getAffineConeBuilders()

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)

描述

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

若参数 qconstrs 为 None，则返回全部二次约束相应构建器组成的一个 QConstrBuilderArray类对象；若参数 qconstrs 为 QConstraint类对象，则返回指定约束相应的 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)

描述

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

若参数 constrs 为 None，则返回全部半定约束相应构建器组成的一个 PsdConstrBuilderArray类对象；若参数 constrs 为 PsdConstraint类对象，则返回指定半定约束相应的 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.loadCone()

摘要

loadCone(ncone, types, dims, indices)

描述

加载二阶锥到模型中。

参量

ncone

二阶锥的个数。

types

二阶锥的类型，可取值请参考二阶锥约束类型。

dims

二阶锥的维度。

indices

构成二阶锥的变量的下标数组。

Model.loadExpCone()

摘要

loadExpCone(ncone, types, indices)

描述

加载指数锥到模型中。

参量

ncone

指数锥的个数。

types

指数锥的类型，可取值请参考指数锥约束类型。

indices

构成指数锥的变量的下标数组。

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)

描述

获取指定变量的基状态。

若参数 vars 为 None，则返回全部变量的基状态组成的一个列表对象；若参数 vars 为 Var类对象，则返回指定变量的基状态；若参数 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)

描述

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

若参数 constrs 为 None，则返回全部线性约束的基状态组成的一个列表对象；若参数 constrs 为 Constraint类对象，则返回指定线性约束的基状态；若参数 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 个解中指定变量的取值。

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

参量

isol

解池中解的索引。

vars

指定的变量。

示例

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

Model.getVarLowerIIS()

摘要

getVarLowerIIS(vars)

描述

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

若参数 vars 为 Var类对象，则返回指定变量下边界的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状态。

若参数 vars 为 Var类对象，则返回指定变量上边界的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状态。

若参数 constrs 为 Constraint类对象，则返回指定约束下边界的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状态。

若参数 constrs 为 Constraint类对象，则返回指定约束上边界的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状态。

若参数 soss 为 SOS类对象，则返回指定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状态。

若参数 genconstrs 为 GenConstr类对象，则返回指定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)

描述

获取指定变量或约束的信息值。

若参数 args 为 Var类对象或 Constraint类对象，则返回指定变量或约束的信息值常数；

若参数 args 为列表、VarArray类对象或 ConstrArray类对象，则返回指定变量或约束的信息值组成的一个列表对象；

若参数 args 为字典或 tupledict类对象，则返回键为指定变量或约束的下标，值为指定变量或约束的信息值组成的一个 tupledict类对象；

若参数 args 为 MVar类对象、 MConstr类对象、 MQConstr 类对象或 MPsdConstr类对象，则返回指定变量或约束的信息值组成的一个 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)

描述

获取指定变量的类型。

若参数 vars 为 Var类对象，则返回指定变量的类型；若参数 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)

描述

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

参量

varbasis

变量的基状态。

constrbasis

线性约束的基状态。

示例

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

Model.setSlackBasis()

摘要

setSlackBasis()

描述

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

示例

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

Model.setVarType()

摘要

setVarType(vars, vartypes)

描述

设置指定变量的类型。

若参数 vars 为 Var类对象，则参数 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类， GenConstr类或 AffineCone类，以及有它们构成的列表或者字典对象。

names

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

示例

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

Model.setMipStart()

摘要

setMipStart(vars, startvals)

描述

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

若参数 vars 为 Var类对象，则参数 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)

描述

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

若参数 args 为 Var类对象或 Constraint类对象，则参数 newvals 为常量；

若参数 args 为字典或 tupledict类对象，则参数 newvals 可为常量、字典或 tupledict类对象；

若参数 args 为列表 VarArray类对象或 ConstrArray类对象，则参数 newvals 可为常量或列表对象；

若参数 args 为 MVar类对象、 MConstr类对象、 MQConstr 类对象或 MPsdConstr类对象，则参数 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 可取值为 ExpCone类对象、ExpConeArray类对象、列表、字典或 tupledict类对象；

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

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

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

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

若移除仿射锥约束，则参数 args 可取值为 AffineCone类对象、AffineConeArray类对象；

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

参量

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类对象。

若参数 vars 为 None，则创建一个空的 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.diag()

摘要

diag(offset=0)

描述

获取半定变量的对角元。

参量

offset

对角偏移量，默认值为0。

若 offset 大于0，则表示向下三角偏移；若 offset 小于0，则表示向上三角偏移。

返回值

PsdExpr 对象。

示例

# 获取半定变量主对角元
v.diag(offset=0)

PsdVar.pick()

摘要

pick(indexes)

描述

获取半定变量中由指定下标构成的半定表达式。

参量

indexes

指定的下标数组。

返回值

PsdExpr 对象。

示例

# 获取半定变量中下标为0的元素构成的半定表达式
barX = model.addPsdVars(3, "BAR_X")
barX.pick([0])

PsdVar.sum()

摘要

sum()

描述

获取半定变量全部项相加构成的半定表达式。

返回值

PsdExpr 对象。

PsdVar.toexpr()

摘要

toexpr()

描述

获取半定变量等价的半定表达式。

返回值

PsdExpr 对象。

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类对象。

若参数 vars 为 None，则创建一个空的 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类对象。

若参数 mats 为 None，则创建一个空的 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类对象。

若参数 constrs 为 None，则创建一个空的 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, rhs)

描述

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

参量

expr

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

sense

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

rhs

约束右端项。

示例

# 设置线性约束构建器的表达式为：x + y == 1
constrbuilder.setBuilder(x + y, COPT.EQUAL, 1)

ConstrBuilder.getExpr()

摘要

getExpr()

描述

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

示例

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

ConstrBuilder.getSense()

摘要

getSense()

描述

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

示例

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

ConstrBuilderArray类

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

ConstrBuilderArray()

摘要

ConstrBuilderArray(constrbuilders=None)

描述

创建一个 ConstrBuilderArray类对象。

若参数 constrbuilders 为 None，则创建一个空的 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类对象。

若参数 qconstrs 为 None，则创建一个空的 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类对象。

若参数 qconstrbuilders 为 None，则创建一个空的 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类对象。

若参数 constrs 为 None，则创建一个空的 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类对象。

若参数 builders 为 None，则创建一个空的 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类对象。

若参数 constrs 为 None，则创建一个空的 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类对象。

若参数 soss 为 None，则创建一个空的 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类对象。

若参数 sosbuilders 为 None，则创建一个空的 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类对象。

若参数 cones 为 None，则创建一个空的 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类对象。

若参数 conebuilders 为 None，则创建一个空的 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()

ExpCone类

ExpCone类是杉数求解器指数锥约束的相关操作的封装，目前提供了以下成员方法：

ExpCone.getIdx()

摘要

getIdx()

描述

获取指数锥约束在模型中的下标。

示例

# 获取指数锥约束expcone的下标
coneidx = expcone.getIdx()

ExpCone.remove()

摘要

remove()

描述

从模型中删除当前指数锥约束。

示例

# 删除指数锥约束expcone
expcone.remove()

ExpConeArray类

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

ExpConeArray()

摘要

ExpConeArray(cones=None)

描述

创建一个 ExpConeArray类对象。

若参数 cones 为 None，则创建一个空的 ExpConeArray类对象，否则以参数 cones 初始化新创建的 ExpConeArray类对象。

参量

cones

待添加指数锥约束。可选参量，默认为 None。可取值为 ExpCone类对象、 ExpConeArray类对象、列表、字典或 tupledict类对象。

示例

# 创建一个新的ExpConeArray对象
conearr = ExpConeArray()
# 创建一个ExpConeArray对象，并使用指数锥约束conex和coney初始化
conearr = ExpConeArray([conex, coney])

ExpConeArray.pushBack()

摘要

pushBack(cone)

描述

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

参量

cone

待添加指数锥约束。可取值为 ExpCone类对象、ExpConeArray类对象、列表、字典或 tupledict类对象。

示例

# 添加指数锥约束conex到conearr中
conearr.pushBack(conex)
# 添加指数锥约束conex和coney到conearr中
conearr.pushBack([conex, coney])

ExpConeArray.getCone()

摘要

getCone(idx)

描述

根据指数锥约束在 ExpConeArray类对象中的下标获取相应的指数锥约束，返回一个 ExpCone类对象。

参量

idx

指数锥约束在 ExpConeArray类对象中的下标。起始为0。

示例

# 获取conearr中下标为1的指数锥约束
cone = conearr.getCone(1)

ExpConeArray.getSize()

摘要

getSize()

描述

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

示例

# 获取conearr中指数锥约束的个数
arrsize = conearr.getSize()

ExpConeBuilder类

ExpConeBuilder类是杉数求解器中构建指数锥约束的构建器的封装，提供了以下成员方法：

ExpConeBuilder()

摘要

ExpConeBuilder()

描述

创建一个空的 ExpConeBuilder类对象。

示例

# 创建一个空的ExpConeBuilder对象
ExpConeBuilder = ExpConeBuilder()

ExpConeBuilder.setBuilder()

摘要

setBuilder(conetype, vars)

描述

设置 ExpConeBuilder类对象的类型、变量。

参量

conetype

指数锥约束类型，可取值详见指数锥约束类型。

vars

指数锥约束的变量，可取值为 VarArray类对象、列表、字典或 tupledict类对象。

示例

# 设置指数锥约束构建器的类型为原始指数锥
ExpConeBuilder.setBuilder(COPT.EXPCONE_PRIMAL, [z, x, y])

ExpConeBuilder.getType()

摘要

getType()

描述

获取 ExpConeBuilder类对象的指数锥约束类型。

示例

# 获取指数锥约束构建器conex的类型
conetype = ExpConeBuilder.getType(conex)

ExpConeBuilder.getVar()

摘要

getVar(idx)

描述

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

参量

idx

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

示例

# 获取指数锥约束构建器conex中下标为1的变量
conevar = conex.getVar(1)

ExpConeBuilder.getVars()

摘要

getVars()

描述

获取 ExpConeBuilder类对象的所有变量，返回一个 VarArray类对象。

示例

# 获取指数锥约束构建器conex中的所有变量
conevars = conex.getVars()

ExpConeBuilder.getSize()

摘要

getSize()

描述

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

示例

# 获取指数锥约束构建器conex中元素的个数
conesize = conex.getSize()

ExpConeBuilderArray类

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

ExpConeBuilderArray()

摘要

ExpConeBuilderArray(ExpConeBuilders=None)

描述

创建一个 ExpConeBuilderArray类对象。

若参数 ExpConeBuilders 为 None，则创建一个空的 ExpConeBuilderArray类对象，否则以参数 ExpConeBuilders 初始化新创建的 ExpConeBuilderArray类对象。

参量

ExpConeBuilders

待添加指数锥约束构建器。可选参量，默认为 None。可取值为 ExpConeBuilder类对象、 ExpConeBuilderArray类对象、列表、字典或 tupledict类对象。

示例

# 创建一个空的ExpConeBuilderArray对象
ExpConeBuilderarr = ExpConeBuilderArray()
# 创建一个ExpConeBuilderArray对象，并使用指数锥约束构建器conex和coney初始化
ExpConeBuilderarr = ExpConeBuilderArray([conex, coney])

ExpConeBuilderArray.pushBack()

摘要

pushBack(ExpExpConeBuilder)

描述

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

参量

ExpExpConeBuilder

待添加指数锥约束构建器。可取值为 ExpConeBuilder类对象、ExpConeBuilderArray类对象、列表、字典或 tupledict类对象。

示例

# 添加指数锥约束构建器conex到ExpConeBuilderarr中
ExpConeBuilderarr.pushBack(conex)

ExpConeBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据指数锥约束构建器在 ExpConeBuilderArray类对象中的下标获取相应的构建器。

参量

idx

指数锥约束构建器在 ExpConeBuilderArray类对象中的下标。起始为0。

示例

# 获取ExpConeBuilderarr中下标为1的指数锥约束构建器
ExpExpConeBuilder = ExpConeBuilderarr.getBuilder(1)

ExpConeBuilderArray.getSize()

摘要

getSize()

描述

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

示例

# 获取ExpConeBuilderarr中元素的个数
ExpConeBuildersize = ExpConeBuilderarr.getSize()

AffineCone类

AffineCone类是杉数求解器仿射锥约束的相关操作的封装，目前提供了以下成员方法：

AffineCone.getIdx()

摘要

getIdx()

描述

获取仿射锥约束在模型中的下标。

示例

# 获取仿射锥约束afcone的下标
afconeidx = afcone.getIdx()

AffineCone.getName()

摘要

getName()

描述

获取仿射锥约束的名称。

示例

# 获取仿射锥约束afcone的名称
afconename = afcone.getName()

AffineCone.setName()

摘要

setName(newname)

描述

设置仿射锥约束的名称。

参量

newname

仿射锥的名称

示例

# 设置仿射锥约束afcone的名称
afcone.setName("afcone")

AffineCone.remove()

摘要

remove()

描述

从模型中删除当前仿射锥约束。

示例

# 从模型中删除当前仿射锥afcone
afcone.remove()

AffineConeArray类

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

AffineConeArray()

摘要

AffineConeArray(cones=None)

描述

创建一个 AffineConeArray类对象。

若参数 cones 为 None，则创建一个空的 AffineConeArray类对象，否则以参数 cones 初始化新创建的 AffineConeArray类对象。

参量

cones

待添加仿射锥约束。可选参量，默认为 None。可取值为 AffineCone类对象、 AffineConeArray类对象、列表、字典或 tupledict类对象。

示例

# 创建一个空的AffineConeArray对象
afconearr = AffineConeArray()
# 创建一个AffineConeArray对象，并使用仿射锥约束afconex和afconey初始化
afconearr = AffineConeArray([afconex, afconey])

AffineConeArray.pushBack()

摘要

pushBack(cone)

描述

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

参量

cone

待添加仿射锥约束。可取值为 AffineCone类对象、AffineConeArray类对象、列表、字典或 tupledict类对象。

示例

# 添加仿射锥约束afconex到afconearr中
afconearr.pushBack(afconex)
# 添加仿射锥约束afconex和afconey到afconearr1中
afconearr.pushBack([afconex, afconey])
# 添加仿射锥约束afcone1和afcone2到afconearr2中
dict_cone = {'AC': afcone1, 'CA': afcone2}
afconearr2 = AffineConeArray({'AC': afcone1, 'CA': afcone2})

AffineConeArray.getCone()

摘要

getCone(idx)

描述

根据仿射锥在 AffineConeArray类对象中的下标获取相应的仿射锥约束，返回一个 AffineCone类对象。

参量

idx

仿射锥约束在 AffineConeArray类对象中的下标。起始为0。

返回值

示例

# 获取afconearr中下标为1的仿射锥约束
afcone = afconearr.getCone(1)

AffineConeArray.getSize()

摘要

getSize()

描述

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

示例

# 获取afconearr中仿射锥约束的个数
arrsize = afconearr.getSize()

AffineConeBuilder类

AffineConeBuilder类是杉数求解器中构建仿射锥约束的构建器的封装，提供了以下成员方法：

AffineConeBuilder()

摘要

AffineConeBuilder()

描述

创建一个空的 AffineConeBuilder类对象。

示例

# 创建一个空的AffineConeBuilder对象
afconebuilder = AffineConeBuilder()

AffineConeBuilder.setBuilder()

摘要

setBuilder(conetype, exprs)

描述

设置仿射锥构建器。

参量

conetype

仿射锥类型，可取值详见二阶锥约束类型和指数锥约束类型。

exprs

构成仿射锥的数学表达式，可取值为线性表达式或半定表达式。

示例

# 设置仿射锥约束构建器的类型为标准二阶锥，由z, x+y, y构成
afconebuilder = AffineConeBuilder()
afconebuilder.setBuilder(COPT.CONE_QUAD, [z, x+y, y])

AffineConeBuilder.hasPsdTerm()

摘要

hasPsdTerm()

描述

检查仿射锥构建器中是否含有半定项。

返回值

Bool。如果取值为 False ，表示仿射锥的表达式里没有半定项。从而可以直接获取线性表达式。

AffineConeBuilder.getType()

摘要

getType()

描述

获取 AffineConeBuilder类对象的仿射锥约束类型。

示例

# 获取仿射锥约束构建器afconex的类型
afconetype = afconebuilder.getType(afconex)

AffineConeBuilder.getExpr()

摘要

getExpr(idx)

描述

获取仿射锥约束构建器中指定下标的表达式。

参量

idx

指定待获取表达式在仿射锥约束构建器中的下标。

返回值

若存在半定项，则返回 PsdExpr 对象；若不存在半定项，则返回 LinExpr 对象。

示例

# 获取仿射锥约束构建器中下标为0的表达式
expr = afconstrbuilder.getExpr(0)

AffineConeBuilder.getPsdExpr()

摘要

getPsdExpr(idx)

描述

获取仿射锥约束构建器中指定下标的半定表达式。

参量

idx

指定待获取半定表达式在仿射锥约束构建器中的下标。

返回值

返回 PsdExpr 对象。

示例

# 获取仿射锥约束构建器中下标为0的半定表达式
psdexpr = afconstrbuilder.getPsdExpr(0)

AffineConeBuilder.getExprs()

摘要

getExprs(idx=None)

描述

获取仿射锥约束构建器中指定序号的一组表达式。

参量

idx

指定待获取表达式在仿射锥约束构建器中的下标。

若 idx 为 None ，则返回仿射锥所有的表达式；若 idx 为 Python 列表对象，则返回仿射锥指定序号的一组表达式。

返回值

若存在半定项，则返回 PsdExpr 对象；若不存在半定项，则返回 LinExpr 对象。

示例

# 获取仿射锥约束构建器中全部项的表达式
allexprs = afconstrbuilder.getExprs()

AffineConeBuilder.getPsdExprs()

摘要

getPsdExprs(idx=None)

描述

获取仿射锥约束构建器中指定序号的一组半定表达式。

参量

idx

指定待获取半定表达式在仿射锥约束构建器中的下标。

若 idx 为 None ，则返回仿射锥所有的半定表达式；若 idx 为 Python 列表对象，则返回仿射锥指定序号的一组半定表达式。

返回值

返回 PsdExpr 对象。

示例

# 获取仿射锥约束构建器中全部的半定表达式
allpsdexprs = afconstrbuilder.getPsdExprs()

AffineConeBuilder.getSize()

摘要

getSize()

描述

获取仿射锥约束构建器中表达式的个数。

示例

# 获取仿射锥约束构建器中表达式的个数
afconesize = afconebuilder.getSize()

AffineConeBuilderArray类

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

摘要

AffineConeBuilderArray(conebuilders=None)

描述

创建一个 AffineConeBuilderArray类对象。

若参数 conebuilders 为 None，则创建一个空的 AffineConeBuilderArray类对象；否则以参数 conebuilders 初始化新创建的 AffineConeBuilderArray类对象。

参量

conebuilders

待添加仿射锥约束构建器。可选参量，默认为 None。可取值为 AffineConeBuilder类对象、 AffineConeBuilderArray类对象、列表、字典或 tupledict类对象。

示例

# 创建一个空的AffineConeBuilderArray对象
conebuilderarr = AffineConeBuilderArray()
# 创建一个AffineConeBuilderArray对象，并使用仿射锥约束构建器conex和coney初始化
conebuilderarr = AffineConeBuilderArray([conex, coney])

AffineConeBuilderArray.pushBack()

摘要

pushBack(AffineConeBuilder)

描述

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

参量

AffineConeBuilder

待添加仿射锥约束构建器。可取值为 AffineConeBuilder类对象、AffineConeBuilderArray类对象、列表、字典或 tupledict类对象。

示例

# 添加仿射锥约束构建器afconex到afconebuilderarr中
afconebuilderarr.pushBack(afconex)

AffineConeBuilderArray.getBuilder()

摘要

getBuilder(idx)

描述

根据仿射锥约束构建器在 AffineConeBuilderArray类对象中的下标获取相应的构建器。

参量

idx

仿射锥约束构建器在 AffineConeBuilderArray类对象中的下标。起始为0。

示例

# 获取afconebuilderarr中下标为1的仿射锥约束构建器
affineConeBuilder = afconebuilderarr.getBuilder(1)

AffineConeBuilderArray.getSize()

摘要

getSize()

描述

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

示例

# 获取afconebuilderarr中元素的个数
afconebuildersize = afconebuilderarr.getSize()

GenConstr类

GenConstr类是杉数求解器的Indicator约束的相关操作的封装，提供了以下成员方法：

关于Indicator约束的介绍请参考特殊约束：Indicator约束章节。

GenConstr.getName()

摘要

getName()

描述

获取Indicator约束的名称。

示例

# 获取Indicator约束indicx的名字
indiname = indicx.getName()

GenConstr.setName()

摘要

setName(newname)

描述

设置Indicator约束的名称为指定的 newname 。

示例

# 设置Indicator约束indicx的名字为"if"
indicx.setName("if")

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类对象。

若参数 genconstrs 为 None，则创建一个空的 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, type=COPT.INDICATOR_IF)

描述

设置 GenConstrBuilder类对象的Indicator变量、Indicator变量的取值、线性约束表达式和类型，以及Indicator约束的类型。

参量

var

Indicator变量。

val

Indicator变量的取值。

expr

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

sense

线性约束的类型。可取值详见约束类型。

type

Indicator约束的类型。默认为 COPT.INDICATOR_IF （If-Then类型约束），可取值详见 Indicator约束类型。

示例

# 设置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()

GenConstrBuilder.getIndType()

摘要

getIndType()

描述

获取 GenConstrBuilder类对象的Indicator约束类型。

示例

# 获取Indicator约束构建器genbuilderx的Indicator约束类型
linsense = genbuilderx.getIndType()

GenConstrBuilderArray类

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

GenConstrBuilderArray()

摘要

GenConstrBuilderArray(genconstrbuilders=None)

描述

创建一个 GenConstrBuilderArray类对象。

若参数 genconstrbuilders 为 None，则创建一个空的 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类对象。

若参数 constrs 为 None，参数 coeffs 为 None，则创建一个空的 Column类对象，否则采用参数 constrs 和 coeffs 初始化新创建的 Column类对象。若参数 constrs 为 Constraint类对象或 Column类对象，则参数 coeffs 为常数，当参数 coeffs 为 None，则当作常数1.0；若参数 constrs 为列表对象，参数 coeffs 为 None，则参数 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)

描述

添加单个或多个新项。

若参数 constrs 为 Constraint类对象，则参数 coeffs 为常数；若参数 constrs 为 ConstrArray类对象或列表对象，则参数 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 为常数，则移除指定下标对应的项；否则参数 item 为 Constraint类对象。

参量

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类对象。

若参数 columns 为 None，则创建一个空的 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_2x3 = 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)

MQConstr 类

MQConstr类是COPT中多维二次约束的类，支持NumPy的多维数组运算。在矩阵建模功能的内测模式（ Model.matrixmodelmode = "experimental" ）下，可以通过 Model类的方法 addMQConstr 或者 addQConstr 生成。提供了以下成员方法：

MQConstr.getInfo()

摘要

getInfo(infoname)

描述

获取MQConstr类对象内每个二次约束的信息值。

参量

infoname

待获取信息的名称。可取值详见信息章节。

返回值

返回一个与MQConstr对象形状相同的COPT内置NdArray类对象，其元素是相应MQConstr约束对象的信息值。

示例
mx = m.addMVar((1, 3), nameprefix="mx")
mc = m.addQConstr(mx @ mx.T <= 1.0)
print(mc.getInfo("x"))

MQConstr.item()

摘要

item()

描述

获取0维MQConstr对象内的二次约束。如果MQConstr对象不是0维，则触发ValueError异常。

返回值

返回二次约束对象。

示例
mc = m.addQConstr(mx @ mx.T <= 1.0)
print(mc.item())

MQConstr.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的MQConstr对象，其元素保持不变，但形状按参量shape转换。

参量

shape

取值为整数，或者整数元组。表示新MQConstr对象的形状。

order

可选参量，默认为字符'C'，表示兼容C语言，即按行存储； experimental 模式暂不支持 'F' 模式。

返回值

返回一个元素和原MQConstr对象相同，但形状不同的新MQConstr对象。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
mc_1x9 = mc.reshape((1, 9))

MQConstr.setInfo()

摘要

setInfo(infoname, newval)

描述

设置MQConstr对象内每个二次约束的信息值。

参量

infoname

待设置的信息名称。可取值详见信息章节。

newval

待设置新的信息取值。

示例
mc = model.addQConstr(mx @ mx.T <= 1.0)
mc.setInfo("LB", 9.0)

MQConstr.tolist()

摘要

tolist()

描述

把MQConstr对象转化为元素为约束的一维列表。

返回值

返回包含 QConstraint类对象的一维列表。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
print(mc.tolist())

MQConstr.transpose()

摘要

transpose()

描述

生成一个新的MQConstr对象，它是原MQConstr对象的转置。

返回值

返回转置后的MQConstr对象。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
print(mc.transpose())

MQConstr.ndim

摘要

ndim

描述

MQConstr对象的维度。

返回值

整型值。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
print(mc.ndim)

MQConstr.shape

摘要

shape

描述

MQConstr对象的形状。

返回值

整型元组。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
print(mc.shape)

MQConstr.size

摘要

size

描述

MQConstr对象中的约束个数。

返回值

整型值。

示例
mc = m.addQConstr(mx.T @ mx <= 1.0)
print(mc.size)

MQConstr.T

摘要

T

描述

MQConstr对象的转置。类似于类方法 transpose() 。

返回值

返回转置后的MQConstr对象。

示例
A = np.ones([4, 3])
mx = model.addMVar((3, 4), nameprefix="mx")
mc = model.addQConstr(mx @ A @ mx == 0.0)
print(mc.shape) # shape = (3, 4)
print(mc.T.shape) # shape = (4, 3)

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)

MPsdConstr类

MPsdConstr类是杉数求解器中用于构建多维半定约束的类。需要通过模型类的方法addConstr或者addConstrs来生成。提供了以下成员方法：

MPsdConstr.getInfo()

摘要

getInfo(infoname)

描述

获取MPsdConstr内每个半定约束的信息值。

参量

infoname

待获取信息的名称。可取值详见信息章节。

返回值

返回以多维数组保存的半定约束的信息值。

示例
mpsdcon =  model.addConstr(barX[:-1, :-1].sum() == 1)
print(mpsdcon.UB)
print(mpsdcon.getInfo("UB"))

MPsdConstr.setInfo()

摘要

setInfo(infoname, newval)

描述

设置MPsdConstr内每个半定约束的信息值。

参量

infoname

待设置的信息名称。可取值详见信息章节。

newval

待设置新的信息取值。

示例
barX = model.addPsdVars(3, "BAR_X")
mY = model.addMVar(2, nameprefix="M_X")
mpsdCon = model.addConstrs(barX[:-1, :-1].diagonal()== mY)
mpsdCon.UB = 10
mpsdCon.setInfo("UB", 10)

MPsdConstr.item()

摘要

item()

描述

获取0维MPsdConstr内的半定约束对象。如果MPsdConstr对象不是0维，触发ValueError异常。

返回值

返回 PsdConstraint 类对象。

示例
barX = model.addPsdVars(3, "BAR_X")
mY = model.addMVar(2, nameprefix="M_X")
mpsdCon = model.addConstrs(barX[:-1, :-1].diagonal()== mY)
psdCon = mpsdCon[1].item()

MPsdConstr.clone()

摘要

clone()

描述

深度复制一个 MPsdConstr类对象。

返回值

新的MPsdConstr对象。

示例
barX = model.addPsdVars(3, "BAR_X")
mY = model.addMVar(2, nameprefix="M_X")
mpsdCon = model.addConstrs(barX[:-1, :-1].diagonal()== mY)
mpsdCon_copy = mpsdCon.clone()

MPsdConstrBuilder类

MPsdConstrBuilder类是杉数求解器中多维半定约束的生成器，需要通过一组 PsdConstrBuilder类对象生成，或者 MVar类对象，MPsdExpr类对象的比较运算符重载来生成。提供了以下成员方法：

MPsdConstrBuilder()

摘要

MPsdConstrBuilder()

描述

创建一个空的 MPsdConstrBuilder类对象。

示例

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

MPsdConstrBuilder.setBuilder()

摘要

setBuilder(expr, sense, rhs)

描述

设置多维半定约束构建器的表达式和约束类型。

参量

expr

待设置表达式。可取值为常数、 MVar类对象、 MLinExpr类对象或 MPsdExpr类对象。

sense

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

rhs

约束右端项。可取值为常数、 MVar类对象、 MLinExpr类对象或 MPsdExpr类对象。

示例

# 设置多维半定约束构建器的表达式为：x + y == 1
constrbuilder.setBuilder(x + y, COPT.EQUAL, 1)

MPsdConstrBuilder.setRange()

摘要

setRange(expr, range)

描述

设置多维半定约束构建器的表达式和右端项，即约束上下界之差；形式为 expr 小于等于0, 且大于等于 - range 。

参量

expr

待设置表达式。可取值为 MPsdExpr类对象。

range

Range约束的右端项, 非负。

示例

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

MPsdConstrBuilder.getPsdExpr()

摘要

getPsdExpr()

描述

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

示例

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

MPsdConstrBuilder.getSense()

摘要

getSense()

描述

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

示例

# 获取多维半定约束构建器的约束类型
consense = constrbuilder.getSense()

MPsdConstrBuilder.getRange()

摘要

getRange()

描述

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

示例

# 获取多维半定约束构建器的range右端项
rngval = constrbuilder.getRange()

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)

NdArray类

NdArray类是COPT中内置的多维数组类，由相同类型的元素构成并且通过整数元组索引。提供了以下成员方法：

NdArray()

摘要

NdArray(args=None, dtype=None, shape=None)

描述

创建一个 NdArray类对象。

返回值

返回NdArray对象。

示例
# 创建一个形状为3x3的NdArray对象，并将其中元素初始化为0
ndmat = NdArray(shape=(3, 3))

NdArray.item()

摘要

item()

描述

获取0维NdArray对象内的单个元素。如果NdArray对象不是0维，则会触发 ValueError 异常。

返回值

返回0维NdArray对象中元素的数据类型。（例如： "float" 或者 "int" 等）

示例
ndmat = NdArray(args=1.1, shape=(1,))
# Type of value is "float"
value = ndmat.item()

NdArray.reshape()

摘要

reshape(shape, order='C')

描述

返回一个新的NdArray对象，其元素保持不变，但形状按参量shape转换。

参量

shape

取值为整数，或者整数元组。表示新NdArray对象的形状。

order

可选参量，默认为字符'C'，表示兼容C语言，即按行存储。当前版本还不支持字符'F'，即按列存储。

返回值

返回一个元素和原NdArray对象相同，但形状不同的新NdArray对象。

示例
ndmat = NdArray(shape=(6,))
ndmat_2x3 = ndmat.reshape((2, 3))

NdArray.sum()

摘要

sum(axis=None)

描述

按给定的轴对NdArray里的元素求和。

参量

axis

可选整型参量，默认值为None，即逐个元素求和。否则，按给定的轴求和。

返回值

如果axis为空，返回一个新的0维NdArray对象，其中的元素取值表示对应元素的和。如果axis非空，返回一个新的N-1维NdArray对象，其中的元素为按给定的轴上元素的和。

示例
ndmat = NdArray(args=1.1, shape=(2, 2))
sum_all = ndmat.sum() #对ndmat中所有元素加和，返回0维NdArray对象
sum_row = ndmat.sum(axis=0) #对ndmat中元素按行加和，返回1维NdArray对象，形状为(2, )

NdArray.tolist()

摘要

tolist()

描述

将NdArray对象转化为一维列表。

返回值

返回一维列表list对象。

示例
# Type of object mat_tolist is "list"
mat_tolist = ndmat.tolist()

NdArray.tonumpy()

摘要

tonumpy()

描述

将NdArray对象转化为NumPy的ndarray对象。

返回值

返回numpy ndarray对象。

示例
# Type of object mat_tolist is "numpy.ndarray"
mat_tonumpy = ndmat.tonumpy()

NdArray.fill()

摘要

fill(value)

描述

将NdArray对象中每个元素填充为指定值。

参量

value

NdArray对象中每个元素新的取值。

返回值

返回ndarray对象。

示例
mat_fillvalue = ndmat.fill(100.0)

NdArray.expand()

摘要

expand(axis=0)

描述

将NdArray对象在axis轴上扩展成N+1维形状。

参量

axis

指定的维度，默认为0（即第一个维度）。

返回值

返回N+1维的NdArray对象。

示例
mat_1 = ndmat.expand()

NdArray.squeeze()

摘要

squeeze(axis=0)

描述

将NdArray对象在axis轴上缩减成N-1维形状。

参量

axis

指定的维度，默认为0（即第一个维度）。

返回值

返回N-1维的NdArray对象。

示例
mat_1 = ndmat.squeeze()

NdArray.flatten()

摘要

flatten()

描述

将NdArray对象展开成一维形状。

返回值

返回新的一维NdArray对象。

示例
ndmat = NdArray(shape=(2, 2))
# The shape of mat_1 is (4,)
mat_1 = ndmat.flatten()

NdArray.setItem()

摘要

setItem(idx, value)

描述

设置NdArray对象中给定索引对应元素的取值。

参量

idx

指定的一维索引，即把NdArray展开成一维后对应的索引值。

value

指定一维索引对应元素的新取值。

返回值

返回NdArray对象，其中 idx 的元素取值被设置为 value 。

示例
# 设置第0个索引的元素取值为100
mat_1 = ndmat.setItem(0, 100)

NdArray.transpose()

摘要

transpose()

描述

生成一个新的NdArray对象，它是原NdArray对象的转置。

返回值

返回新的NdArray对象。

示例
ndmat = NdArray(shape=(3, 5))
print(ndmat.transpose().shape) #其形状为(5, 3)

NdArray.diagonal()

摘要

diagonal(offset=0, axis1=0, axis2=1)

描述

生成一个 NdArray类对象，其元素是原NdArray对象对角线上的元素。

参量

offset

可选参量，表示对角线的偏移量，默认值为0。如果值大于0，表示对角线向上的偏移量；如果值小于0，表示对角线向下的偏移量。

axis1

可选参量，用来作为二维子NdArray的第一轴的轴,对角线应该从这里开始。默认第一轴为0。

axis2

可选参量，用来作为二维子NdArray的第二轴的轴,对角线应该从这里开始。默认第二轴为1。

返回值

新的NdArray对象。

示例
ndmat = NdArray(shape=(3, 3),args=[[1,1,1],[2,2,2],[3,3,3]])

diag_m0 = ndmat.diagonal(0)
diag_a1 = ndmat.diagonal(1)
diag_b1 = ndmat.diagonal(-1)

NdArray.pick()

摘要

pick(indexes)

描述

根据指定的下标，从NdArray对象获取新的多维数组。

参量

indexes

指定的下标。

返回值

返回新的NdArray对象。

Ndarray.hstack()

摘要

hstack(other)

描述

和另一个NdArray对象在水平维度（最后一个维度）上堆叠形成新的NdArray对象。

参量

other

另一个NdArray对象。

返回值

返回新的NdArray对象。

Ndarray.vstack()

摘要

vstack(other)

描述

和另一个NdArray对象在纵向维度上堆叠形成新的NdArray对象。

参量

other

另一个NdArray对象。

返回值

返回新的NdArray对象。

Ndarray.stack()

摘要

stack(other, axis)

描述

和另一个NdArray对象在指定轴方向上堆叠形成新的NdArray对象。

参量

other

另一个NdArray对象。

axis

指定轴方向序号。

返回值

返回新的NdArray对象。

NdArray.ndim

摘要

ndim

描述

NdArray对象的维度。

返回值

整型值。

示例
ndmat = NdArray((3, 5))
print(ndmat.ndim) # ndim = 2

NdArray.shape

摘要

shape

描述

NdArray对象的形状。

返回值

整型元组。

示例
ndmat = NdArray((3, 5))
print(ndmat.shape) # shape = (3, 5)

NdArray.size

摘要

size

描述

NdArray对象的元素个数。

返回值

整型值。

示例
ndmat = NdArray((3, 5))
print(ndmat.size) # size = 15

NdArray.T

摘要

T

描述

NdArray对象的转置，类似于类方法 NdArray.transpose() 。

返回值

返回转置后的NdArray对象。

示例
ndmat = NdArray(shape=(3, 5))
print(ndmat.T.shape) # shape = (5, 3)

ExprBuilder类

ExprBuilder类是杉数求解器中用于构建线性约束的构建器，提供了以下成员方法：

ExprBuilder()

摘要

ExprBuilder(arg1=0.0, arg2=None)

描述

创建一个 ExprBuilder类对象。

若参数 arg1 为常数，参数 arg2 为 None，则创建一个 ExprBuilder类对象，并以参数 arg1 的值初始化；若参数 arg1 为 Var类对象或 ExprBuilder类对象，则参数 arg2 为常数，参数 arg2 可为 None，此时当作常数1.0，并以参数 arg1 和 arg2 初始化新创建的 ExprBuilder类对象；若参数 arg1 和 arg2 为列表对象，则分别表示组成线性表达式的变量、系数，并初始化新创建的 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 为常数，参数 arg2 为 None，则创建一个 LinExpr类对象，并以参数 arg1 的值初始化；若参数 arg1 为 Var类对象或 LinExpr类对象，则参数 arg2 为常数，参数 arg2 可为 None，此时当作常数1.0，并以参数 arg1 和 arg2 初始化新创建的 LinExpr类对象；若参数 arg1 为列表对象，参数 arg2 为 None，则参数 arg1 中的元素为变量、系数对，并以参数 arg1 和 arg2 初始化新创建的 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)

描述

添加单个或多个新项到表达式。

若参数 vars 为 Var类对象，则参数 coeffs 为常数；若参数 vars 为 VarArray类对象或列表对象，则参数 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 为常数，则移除指定下标对应的项；否则参数 item 为 Var类对象。

参量

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)

描述

添加单个或多个新项到表达式。

若参数 vars1 为 Var类对象，则参数 vars2 为 Var类对象或 None ，参数 coeffs 为常数；若参数 vars1 为 VarArray类对象或列表对象，则参数 vars2 为 VarArray类对象、列表对象或 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 为常数，则移除指定下标对应的项；否则参数 item 为 Var类对象。

参量

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)

描述

添加单个或多个新半定项到半定表达式。

若参数 vars 为 PsdVar类对象，则参数 mats 为 SymMatrix类对象；若参数 vars 为 PsdVarArray类对象或列表对象，则参数 mats 为 SymMatrixArray类对象或列表对象；

参量

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.addMExpr()

摘要

addMExpr(expr, mult=1.0)

描述

添加新的多维数组表达式到当前半定表达式中。

参量

expr

待添加多维数组表达式或者多维数组表达式构建器对象。

mult

待添加多维数组表达式的放大系数。可选参量，默认值为1.0。

示例

# 添加多维数组线性表达式：2.0*A@x 到半定表达式expr中
expr.addMExpr(A@x, 2.0)

PsdExpr.clone()

摘要

clone()

描述

创建表达式对象的深拷贝。

示例

# 创建半定表达式expr的深拷贝
exprcopy = expr.clone()

PsdExpr.reserve()

摘要

reserve(n)

描述

为半定表达式对象预分配空间。

参量

n

预分配的半定表达式中项的数目。

示例

# 预分配半定表达式expr中项的数目为100
expr.reserve(100)

PsdExpr.remove()

摘要

remove(item)

描述

从半定表达式中移除指定项。

若参数 item 为常数，则移除指定下标对应的项；否则参数 item 为 PsdVar类对象。

参量

item

常数下标或待移除项相应的半定变量。

示例

# 从半定表达式expr中移除下标为2相应的项
expr.remove(2)
# 从半定表达式expr中移除半定变量x相应的项
expr.remove(x)

MPsdExpr类

MPsdExpr类是杉数求解器中用于构建多维半定表达式时对半定变量的相关组合操作，提供了以下成员方法：

MPsdExpr.addTerm()

摘要

addTerm(var, mat)

描述

添加新的半定项到当前多维半定表达式中。

参量

var

待添加半定项中的半定变量。

mat

待添加半定项中的对称矩阵。

示例

# 添加半定项 C1 * X到多维半定表达式mexpr中
mexpr.addTerm(X, C1)

MPsdExpr.addTerms()

摘要

addTerms(vars, coeffs)

描述

对多维半定表达式对象的半定表达式添加新的项。

参量

vars

多维数组变量对象。可取值为 MVar 。

coeffs

多维数组系数矩阵。可取值为常数或 NdArray 。

示例

# 添加项：mA@到多维半定表达式mpsdexpr中
mX = model.addMVar((3,3), nameprefix="M_X")
mA = cp.NdArray(np.ones(shape=(3,3)))
mpsdexpr.addTerms(mX, mA)

MPsdExpr.addLinExpr()

摘要

addLinExpr(expr, mult=1.0)

描述

添加一个新的线性表达式到当前多维半定表达式中。

参量

expr

待添加线性表达式或者线性表达式构建器对象。可取值为 LinExpr 或 ExprBuilder 对象。

mult

待添加线性表达式的放大系数。可选参量，默认值为1.0。

示例

# 添加线性表达式：2*x + 2*y到半定表达式mexpr中
mexpr.addLinExpr(x + y, 2.0)

MPsdExpr.addPsdExpr()

摘要

addPsdExpr(expr, mult=1.0)

描述

添加新的半定表达式到当前多维半定表达式中。

参量

expr

待添加的半定表达式。

mult

待添加半定表达式的放大系数。可选参量，默认值为1.0。

示例

# 添加半定表达式：C * X到多维半定表达式mexpr中
mexpr.addPsdExpr(C*X)

MPsdExpr.addMExpr()

摘要

addMExpr(expr, mult=1.0)

描述

添加新的多维表达式到当前多维半定表达式中。

参量

expr

待添加多维数组表达式或者多维数组表达式构建器对象。

mult

待添加多维数组表达式的放大系数。可选参量，默认值为1.0。

示例

# 添加多维数组线性表达式：2.0*A@x 到半定表达式mexpr中
mexpr.addMExpr(A@x, 2.0)

MPsdExpr.addMLinExpr()

摘要

addMLinExpr(exprs, mult=1.0)

描述

对多维半定表达式对象的每个半定表达式都添加对应的线性表达式。

参量

exprs

待添加多维线性表达式或者多维线性表达式构建器对象。

mult

待添加多维线性表达式的相同的放大系数。可选参量，默认值为1.0。

示例

# 为多维半定表达式mexpr的每个半定表达式都新增线性表达式A@x
mexpr.addMLinExpr(A@x)

MPsdExpr.addMPsdExpr()

摘要

addMPsdExpr(exprs, mult=1.0)

描述

对多维半定表达式对象的每个半定表达式都添加对应新的半定表达式。

参量

expr

待添加新半定表达式。

mult

待添加新半定表达式的相同的放大系数。可选参量，默认值为1.0。

示例

# 为多维半定表达式mexpr的每个半定表达式都新增半定表达式：C * X
mexpr.addMPsdExpr(C*X)

MPsdExpr.item()

摘要

item()

描述

获取0维半定表达式内的 PsdExpr 。如果 MPsdExpr 对象不是0维，触发 ValueError 异常。

返回值

返回 PsdExpr 对象。

示例
barX = model.addPsdVars(3, "BAR_X")
mpsdexpr = barX[:-1, :-1]
psdexpr1 = mpsdexpr[0,0].item()
psdexpr2 = mpsdexpr.sum().item()

MPsdExpr.sum()

摘要

sum(axis=None)

描述

沿指定坐标轴对MPsdExpr对象中的半定项求和，返回一个新的 MPsdExpr类对象。

参量

axis

可选整型参量，默认值为None，即对所有变量求和。否则，按给定的轴求和。

返回值

返回MPsdExpr对象，表示对应多维半定表达式的和。

MPsdExpr.clear()

摘要

clear()

描述

重置 MPsdExpr类对象的每个元素为0.0。

示例
barX = model.addPsdVars(3, "BAR_X")
mpsdexpr = barX[:-1, :-1]
mpsdexpr.clear()

MPsdExpr.clone()

摘要

clone()

描述

深度复制一个 MPsdExpr类对象。

返回值

新的MPsdExpr对象

示例
barX = model.addPsdVars(3, "BAR_X")
mpsdexpr = barX[:-1, :-1]
newmpsdexpr = mpsdexpr.clone()

LmiExpr类

LmiExpr类是杉数求解器中用于构建LMI约束表达式时变量的相关组合操作，提供了以下成员方法：

LmiExpr()

摘要

LmiExpr(arg1=None, arg2=None)

描述

创建一个 LmiExpr类对象。

参量

arg1 默认值为 None ，可取值为： Var类对象，或 SymMatrix类对象。

若参数 arg1 为 Var类对象，则参数 arg2 为 SymMatrix类对象。

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表达式中添加多个新项。

若参数 vars 为 Var类对象，则参数 mats 为 SymMatrix类对象；若参数 vars 为 VarArray类对象或列表对象，则参数 mats 为 SymMatrixArray类对象或列表对象；

参量

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 为常数，则移除指定下标对应的项；否则参数 item 为 Var类对象。

参量

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, EQUAL 和 FREE 。

通过 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, EQUAL 和 FREE 。

通过 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

指定的变量。

返回值

若参数 args 为 Var类对象，则返回指定变量的信息值常数；

若参数 args 为列表或 VarArray类对象，则返回指定变量的信息值组成的一个列表对象；

若参数 args 为字典或 tupledict类对象，则返回 tupledict类对象（键为指定变量的下标，值为指定变量的信息值）；

若参数 args 为 None, 则返回全部变量当前线性松弛解的信息值。

示例
vals = self.getRelaxSol(vars)

CallbackBase.getIncumbent()

摘要

getIncumbent(vars)

描述

在MIP求解过程中，获取当前最优可行解中指定变量的值。

参量

vars

指定的变量。

返回值

若参数 args 为 Var类对象，则返回指定变量的信息值常数；

若参数 args 为列表或 VarArray类对象，则返回指定变量的信息值组成的一个列表对象；

若参数 args 为字典或 tupledict类对象，则返回 tupledict类对象（键为指定变量的下标，值为指定变量的信息值）；

若参数 args 为 None, 则返回全部变量当前最优可行解的信息值。

示例
vals = self.getIncumbent(vars)

CallbackBase.getSolution()

摘要

getSolution(vars)

描述

在MIP求解过程中，获取当前可行解中指定变量的值。

注意：此方法仅适用于 CallbackBase.where() == COPT.CBCONTEXT_MIPSOL （即找到MIP可行解时）。

参量

vars

指定的变量。

返回值

若参数 args 为 Var类对象，则返回指定变量的信息值常数；

若参数 args 为列表或 VarArray类对象，则返回指定变量的信息值组成的一个列表对象；

若参数 args 为字典或 tupledict类对象，则返回 tupledict类对象（键为指定变量的下标，值为指定变量的信息值）；

若参数 args 为 None, 则返回全部变量当前可行解的信息值。

示例
vals = self.getSolution(vars)

CallbackBase.setSolution()

摘要

setSolution(vars, vals)

描述

在MIP求解过程中，为指定变量设置自定义的可行解，（可以是用户通过任意方式找到的可行解，例如通过启发式算法）。

若参数 vars 为 Var类对象，则参数 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())

repeat()

摘要

repeat(obj, repeats)

描述

将指定的对象重复指定的次数。

参量

obj

Python对象。

repeats

重复的次数。

hstack()

摘要

hstack(left, right)

描述

横向堆叠输入的对象。

参量

left

Python对象。

right

Python对象。

vstack()

摘要

vstack(left, right)

描述

纵向堆叠输入的对象。

参量

left

Python对象。

right

Python对象。

stack()

摘要

stack(left, right, axis)

描述

沿指定轴方向堆叠输入的对象。

参量

left

Python对象。

right

Python对象。

axis

指定的轴方向序号。

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)