Python API 参考手册

Python API 主要包含以下几个模块:

  • Constraint - 用于管理约束条件

  • DataFrame - 用于集合及参数数据的生产和处理

  • MAPL - 用于启动和管理 MAPL 实例

  • Objective - 用于管理目标函数

  • Tuple - 用于表示索引

  • Variable - 用于管理决策变量

每一个接口都有对应的文档和示例，也可以通过 help 函数查看。 在运行接口文档下方的示例前，需要先执行以下语句完成必要的模型初始化。

>>> import maplpy as mp
>>> m = mp.MAPL()
>>> m.read("steel4.mpl")
class maplpy.Constraint

基类：pybind11_object

Constraint - 约束类用于绑定优化模型中的一个 约束条件实体。通过 MAPL.getConstraint 获取并绑定 约束条件实体。 一个 约束条件实体可能只是一条约束，也可能是一条多维约束条件，它是一组同名但是不同索引的约束条件集合。 通过该实体类可以获取约束条件的属性，如名称、上下界、满足条件的表达式值等。

>>> cons = m.getConstraint("Time")
>>> x.lb = 10
>>> x.ub = 20
>>> x.name = "x"
>>> x.value
__getitem__(self: maplpy.Constraint, position: int) → maplpy.Constraint

当约束条件实体为一个约束条件集合时，返回指定位置索引的具体约束条件。 当类存在此内置函数时，意味着可以通过 [] 方法通过位置索引取值。

参数

position (int) – 位置索引值。

返回

约束条件集合中的指定位置索引的具体约束条件。

返回类型

Constraint

>>> cons = m.getConstraint("Time")
>>> con = cons[1]
__init__(*args, **kwargs)
__iter__(self: maplpy.Constraint) → Iterator

当约束条件实体为一个约束条件集合时，对约束条件集合进行迭代遍历。 当类存在此内置函数时，意味着可以通过 for in 方法进行迭代遍历。

>>> cons = m.getConstraint("Time")
>>> for con in cons:
>>>     print(con.name)
__len__(self: maplpy.Constraint) → int

当约束条件实体为一个约束条件集合时，返回约束条件集合的大小。 当类存在此内置函数时，意味着可以通过 len 方法获取约束条件集合的大小。

返回

约束条件集合的大小。

返回类型

int

>>> cons = m.getConstraint("Time")
>>> len(cons)
__repr__(self: maplpy.Constraint) → str

返回约束条件集合的字符串表示。 当约束条件实体为一个约束条件集合时，返回约束条件集合的字符串表示。 当约束条件实体为一条具体约束条件时，返回具体约束的字符串表示。 当类存在此内置函数时，意味着可以直接对类进行输出。

返回

约束条件集合或约束的字符串表示形式。

返回类型

str

>>> cons = m.getConstraint("Time")
>>> print(cons)
>>> for con in cons:
>>>     print(con)
property body

当约束条件实体为一条具体约束条件时，返回根据当前变量值计算后，约束表达式的取值。

返回

约束表达式的值。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].body
property expr

当约束条件实体为一条具体约束条件时，返回约束条件表达式的字符串表示。

返回

约束表达式的字符串表示。

返回类型

str

>>> cons = m.getConstraint("Time")
>>> cons[1].expr
find(self: maplpy.Constraint, *args) → maplpy.Constraint

当约束条件实体为一个约束条件集合时，返回指定 Tuple 索引的具体约束条件。

参数

index (Tuple) – Tuple 索引值。

返回

约束条件集合中的指定``Tuple``索引的具体约束条件。

返回类型

Constraint

>>> cons = m.getConstraint("Time")
>>> t = mp.Tuple(["reheat"])
>>> con_reheat = cons.find(t)
>>> con_roll = cons.find("roll")
property lb

当约束条件实体为一条具体约束条件时，返回约束条件的下界。

返回

约束条件时下界。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].lb
property lbs

当约束条件实体为一个具体约束条件时，返回约束条件的下界。

返回

约束条件时下界。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].lbs
property lslack

当约束条件实体为一个具体约束条件时，返回当前约束值相对约束下界的改善量（差值）。

返回

约束值相对约束下界的改善量（差值）。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].lslack
property name

当约束条件实体为一条具体约束条件时，返回约束条件名称。

返回

约束名称。

返回类型

str

>>> cons = m.getConstraint("Time")
>>> cons[1].name
property num_instances

当约束条件实体为一个约束条件集合时，返回约束条件集合中约束的数量。 也可以使用 len 方法获取约束条件集合的大小。

返回

约束条件集合中约束的数量。

返回类型

int

>>> cons = m.getConstraint("Time")
>>> cons.num_instances
property slack

当约束条件实体为一个具体约束条件时，返回当前约束值相对约束上下界的最小改善量（最小差值）。

返回

约束值相对约束上下界的改善量（差值）。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].slack
property ub

当约束条件实体为一条具体约束条件时，返回约束条件的上界。

返回

约束条件时上界。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].ub
property ubs

当约束条件实体为一个具体约束条件时，返回约束条件的上界。

返回

约束条件时上界。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].ubs
property uslack

当约束条件实体为一个具体约束条件时，返回当前约束值相对约束上界的改善量（差值）。

返回

约束值相对约束上界的改善量（差值）。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].uslack
property value

当约束条件实体为一条具体约束条件时，返回根据当前变量值计算后，约束表达式的取值。

返回

约束表达式的值。

返回类型

float

>>> cons = m.getConstraint("Time")
>>> cons[1].value
class maplpy.DataFrame

基类：pybind11_object

DataFrame 类用来批量生产数据表，有着类似 excel 表格的结构。 既可以通过原生的方法添加数据，也可以通过 pandas.DataFrame 类初始化。

DataFrame 以表格形式处理数据。每一列数据包含一条列头和多条同类型数据。

姓名

年龄

性别

身高

张三

20

男

175

李四

21

女

165

在运行 DataFrame 的接口文档示例前，先执行以下语句完成必要的模型初始化。

>>> data = {
        "name": ["张三", "李四"],
        "age": [20, 21,],
        "sex": ["男", "女"],
        "height": [175, 165]
    }
>>> pd = pandas.DataFrame(data)
>>> pd.set_index(["name", "age"], inplace=True)
>>> md = mp.DataFrame(pd)
>>> print(md)
name   age sex height
张三   20 男  175
李四   21 女  165
>>> m.setData(df)
>>> m.display("nameage");
Name  : nameage
Type  : set
Index : Pseudo: |0|{}
Entries:
    Multi: |2|{["zhangsan", 20], ["李四", 21]}
>>> m.display("height");
Name  : height
Type  : number
Index : Multi: |2|{["zhangsan", 20], ["李四", 21]}
Entries:
    ["zhangsan", 20] -> 175
    ["李四", 21] -> 165
__init__(*args, **kwargs)

Overloaded function.

  1. __init__(self: maplpy.DataFrame) -> None

  2. __init__(self: maplpy.DataFrame, dataframe: object) -> None

    从 pandas.DataFrame 对象初始化数据表对象。

    参数:

    dataframe(object) : pandas.DataFrame 对象。

    >>> data = {
        "name": ["张三", "李四"],
        "age": [20, 21,],
        "sex": ["男", "女"],
        "height": [175, 165]
    }
>>> pd = pandas.DataFrame(data)
>>> pd.set_index(["name", "age"], inplace=True)
>>> md = mp.DataFrame(pd)
addRow(self: maplpy.DataFrame, *args) → maplpy.DataFrame

添加一行数据到数据表对象中。

参数

row (list) – 一行数据。

返回

返回数据表对象以支持链式调用。

返回类型

DataFrame

>>> md.add_row(["王五", 22, "女", 180])
>>> print(md)
name   age sex height
赵三   20 男  175
李四   21 女  165
王五   22 女  180
property comment

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据行的注释符（默认为 ‘’, 无注释）。

返回

数据注释符。

返回类型

str

>>> md.comment = "#"
>>> print(md.comment)
#
property data_names

返回 或 设置 当前数据列的列名的列表。如果未设置，默认使用数据表中数据列的列名的列表。

返回

数据表数据列名的列表。

返回类型

list

>>> md.data_names = ["sex", "height"]
>>> print(md.data_names)
['sex', 'height']
property delimiter

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据行的分隔符（默认为 ‘,’）。

返回

数据分隔符。

返回类型

str

>>> print(md.delimiter)
,
>>> md.delimiter = ";"
>>> print(md.delimiter)
;
property encode

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据要以哪种编码读取（默认为 UTF8）。

返回

数据编码。

返回类型

str

>>> print(md.encode)
Encode.UTF8
>>> md.encode = mp.Encode.GBK
>>> print(md.encode)
Encode.GBK
getValue(self: maplpy.DataFrame, row: int, col: int) → object

获取数据表对象中指定位置的元素。

参数

  • row (int) – 行索引。

  • column (int) – 列索引。

返回

数据表对象中指定位置的元素。

返回类型

int|float|str

>>> print(md.get_value(0, 0))
张三
property header

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据表的表头行号（默认为 -1, 无表头）。

返回

数据表头行数。

返回类型

int

>>> print(md.header)
-1
>>> md.header = 0
>>> print(md.header)
0
property headers

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据表的列名的列表。 当设置了 header，读取 CSV 文件时，会自动更新数据表的列名。

返回

数据表头行名称的列表。

返回类型

list

>>> print(md.headers)
['name', 'age', 'sex', 'height']
>>> md.headers = ['nick', 'age', 'sex', 'height']
>>> print(md.headers)
['nick', 'age', 'sex', 'height']
property index_columns

返回 或 设置 数据表对象的索引列的列表。

返回

数据表对象的索引列的列表。

返回类型

int

>>> print(md.index_columns)
[0, 1]
>>> md.index_columns = [0]
>>> print(md.index_columns)
[0]
property index_name

返回 或 设置 当前索引列的列名。如果未设置，默认使用数据表中索引列的列名的拼接字符串。

返回

数据表索引列名。

返回类型

str

>>> md.index_name = "id_name"
>>> print(md.index_name)
id_name
property pattern

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，数据匹配的模式(默认为 ‘’, 自动匹配)。

  • n - 匹配数字

  • s - 匹配字符串

返回

数据匹配模式。

返回类型

str

>>> print(md.pattern)
>>> md.pattern = "ns"
>>> print(md.pattern)
ns
readCSV(self: maplpy.DataFrame, filepath: str) → maplpy.DataFrame

读取 csv 文件, 调用此接口时，需要首先指定: 数据匹配模式, 数据表头行号(默认: -1), 跳过的行数(默认: 0), 数据分隔符(默认: ;), 注释符(默认: #), 编码类型(默认: UTF8)

参数

filename (str) – CSV 文件路径。

返回

返回数据表对象以支持链式调用。

返回类型

DataFrame

>>> with open("data.csv", "w") as f:
        f.write(
            """Empty X Y Index1 Index2
    1 2 3 4 a
    5 6 7 8 b
    9 10 11 12 cde
    13 14 15 16 fg
    17 18 19 20 hi
    21 22 23 24 gkl
    25 26 27 28 mn"""
        )
>>> md.skip = 1
>>> md.delimiter = " "
>>> md.pattern = "nsnn"
>>> md.read_csv("data.csv")
>>> print(md)
  1  2  3  4  a
  5  6  7  8  b
  9  10 11 12 cde
  13 14 15 16 fg
  17 18 19 20 hi
  21 22 23 24 gkl
  25 26 27 28 mn
readCSVAdvanced(self: maplpy.DataFrame, filepath: str, pattern: str = '', header: int = -1, skip: int = 0, delimiter: str = ', ', comment: str = '', encode: maplpy.Encode = <Encode.UTF8: 1>) → maplpy.DataFrame

读取 csv 文件, 可以同时指定:数据匹配模式, 数据表头行号(默认: -1), 跳过的行数(默认: 0), 数据分隔符(默认: ;), 注释符(默认: #), 编码类型(默认: UTF8)

参数

  • filename (str) – CSV 文件路径。

  • pattern (str) – 数据匹配模式。

  • header (int) – 数据表头行号。

  • skip (int) – 跳过的行数。

  • delimiter (str) – 数据分隔符。

  • comment (str) – 数据注释符。

  • encode (str) – 数据编码。

返回

返回数据表对象以支持链式调用。

返回类型

DataFrame

>>> with open("data.csv", "w") as f:
        f.write(
            """Empty X Y Index1 Index2
    1 2 3 4 a
    5 6 7 8 b
    9 10 11 12 cde
    13 14 15 16 fg
    17 18 19 20 hi
    21 22 23 24 gkl
    25 26 27 28 mn"""
        )
>>> md.read_csv("data.csv", "nsnn", skip=1, delimiter=" ", comment="#")
>>> print(md)
  1  2  3  4  a
  5  6  7  8  b
  9  10 11 12 cde
  13 14 15 16 fg
  17 18 19 20 hi
  21 22 23 24 gkl
  25 26 27 28 mn
setValue(self: maplpy.DataFrame, row: int, col: int, value: object) → None

设置数据表对象中指定位置的元素。

参数

  • row (int) – 行索引。

  • column (int) – 列索引。

  • value (int|float|str) – 要设置的值。

返回

返回数据表对象以支持链式调用。

返回类型

DataFrame

>>> md.set_value(0, 0, "赵三")
>>> print(md.get_value(0, 0))
赵三
property shape

返回数据表对象的行列数。

返回

数据表对象的行列数。

返回类型

tuple

>>> print(md.shape)
(2, 4)
property skip

返回 或 设置 当通过 read_csv 接口读取 CSV 文件时，跳过的行数（默认为 -1，从第非表头行开始）。

返回

跳过的行数。

返回类型

int

>>> md.skip = 1
>>> print(md.skip)
1
property use_columns

返回 或 设置 数据表对象当添加到模型中时需要使用到的列的索引的列表（列索引从0开始计数）。

返回

数据表对象当添加到模型中时需要使用到的列的索引的列表。

返回类型

list

>>> print(md.use_columns)
[0, 1, 2, 3]
>>> md.use_columns = [0, 3]
>>> print(md.use_columns)
[0, 3]
class maplpy.Encode

基类：pybind11_object

Encode 枚举类用来在读取 CSV 文件时指定文件的编码类型。

Members:

GBK :

gbk 编码，用于读取 GB2312 编码的文件。

UTF8 :

utf-8 编码，用于读取 UTF-8 编码的文件。

GBK = <Encode.GBK: 0>
UTF8 = <Encode.UTF8: 1>
__init__(self: maplpy.Encode, value: int) → None
__repr__(self: object) → str
property name
property value
class maplpy.IntOption

基类：pybind11_object

IntOption 枚举类用来指定需要配置的整数类型选项。

Members:

SOLVER_OUTPUT :

SOLVER_OUTPUT 编码，用于指定是否输出求解日志。0：不输出求解日志；1：输出求解日志。默认为 1。

SOLVER_OUTPUT = <IntOption.SOLVER_OUTPUT: 1>
__init__(self: maplpy.IntOption, value: int) → None
__repr__(self: object) → str
property name
property value
class maplpy.Integrality

基类：pybind11_object

Integrality 枚举类用来指定决策变量的类型。

Members:

CONTINUOUS :

CONTINUOUS - 连续变量。

INTEGER :

CONTINUOUS - 连续变量。

BINARY :

BINARY - 二元变量。

IMPLICIT :

IMPLICIT - 隐式变量。

AUXILIARY :

AUXILIARY - 辅助变量。

AUXILIARY = <Integrality.AUXILIARY: 4>
BINARY = <Integrality.BINARY: 2>
CONTINUOUS = <Integrality.CONTINUOUS: 0>
IMPLICIT = <Integrality.IMPLICIT: 3>
INTEGER = <Integrality.INTEGER: 1>
__init__(self: maplpy.Integrality, value: int) → None
__repr__(self: object) → str
property name
property value
class maplpy.MAPL

基类：pybind11_object

MAPL 类用于表示一个模型实例。管理模型的参数、变量、约束、目标、选项等。

>>> import maplpy as mp
>>> m = mp.MAPL("steel")
>>> m.read("steel4.mpl")
>>> m.display("rate")
>>> m.getConstraint("Time")
>>> m.getConstraints()
>>> m.getVariable("Make")
>>> m.getVariables()
>>> m.getObjective("Total_Profit")
>>> m.getOption(mp.StrOption.MODEL_NAME)
>>> m.setOption(mp.StrOption.SOLVER, "mindopt")
>>> m.setOption(mp.StrOption.SOLVER_OPTIONS, "num_threads= 2 print=0")
>>> m.solve()
__init__(*args, **kwargs)

Overloaded function.

  1. __init__(self: maplpy.MAPL) -> None

    初始化一个模型实例。

    >>> m = mp.MAPL()

  2. __init__(self: maplpy.MAPL, arg0: str) -> None

    初始化一个模型实例。

    Args:

    name (str): 模型实例的名称。

    >>> m = mp.MAPL("diet_problem")
display(self: maplpy.MAPL, name: str = '') → None

如果没有指定输出名称，则输出所有模型的解值。 如果指定了输出名称，则输出指定符号的信息。

参数

name (str) – 输出名称。

>>> m.display("rate")
eval(self: maplpy.MAPL, text: str) → None

从字符串中读取建模指令并执行。

参数

text (str) – 建模指令

>>> m.eval()
getConstraint(self: maplpy.MAPL, name: str) → mapl::Constraint

获取模型实例中指定名称的 约束条件实体。

参数

name (str) – 约束名称。

返回

约束条件实体对象。

返回类型

Constraint

>>> m.getConstraint("Time")
<Constraint with 2 constraints>
getConstraints(self: maplpy.MAPL) → List[mapl::Constraint]

获取模型实例中所有的 约束条件实体。

返回

约束条件实体对象的列表。

返回类型

list

>>> m.getConstraints()
[]
getObjective(self: maplpy.MAPL, name: str) → mapl::Objective

获取模型实例中指定名称的目标实体。

参数

name (str) – 目标名称。

返回

目标实体对象。

返回类型

Objective

>>> m.getObjective("Total_Profit")
<Objective with 1 objectives>
getObjectives(self: maplpy.MAPL) → List[mapl::Objective]

获取模型实例中所有的目标实体。

返回

目标实体对象的列表。

返回类型

list

>>> m.getObjectives()
[]
getVariable(self: maplpy.MAPL, name: str) → mapl::Variable

获取模型实例中指定名称的决策变量实体。

参数

name (str) – 决策变量名称。

返回

决策变量实体对象。

返回类型

Variable

>>> m.getVariable("Make")
<Variable with 1 variables>
getVariables(self: maplpy.MAPL) → List[mapl::Variable]

获取模型实例中所有的决策变量实体。

返回

决策变量实体对象的列表。

返回类型

list

>>> m.getVariables()
[]
read(self: maplpy.MAPL, file_path: str) → None

读取模型文件。

参数

file_path (str) – 模型文件路径。

>>> m.read("steel4.mpl")
setData(*args, **kwargs)

Overloaded function.

  1. setData(self: maplpy.MAPL, dataframe: mapl::DataFrame) -> None

    从 maplpy.DataFrame 数据表为模型创建对应的 param 或 set 参数。

    参数:

    data (mapldy.DataFrame): 数据表对象。

    >>> m.setData(md)

  2. setData(self: maplpy.MAPL, dataframe: object) -> None

    从 pandas.DataFrame 数据表为模型创建对应的 param 或 set 参数。

    参数:

    data (pandas.DataFrame): pandas.DataFrame 对象。

    >>> m.setData(pd)
setOption(*args, **kwargs)

Overloaded function.

  1. setOption(self: maplpy.MAPL, option: maplpy.IntOption, value: int) -> None

    设置模型实例的字符穿选项。

    参数:

    option (IntOption): 指定要设置的选项。 value (int): 指定选项的值。

    >>> m.setOption(mp.IntOption.SOLVER_OUTPUT, 0)

  2. setOption(self: maplpy.MAPL, option: maplpy.StrOption, value: str) -> None

    设置模型实例的字符穿选项。

    参数:

    option (StrOption): 指定要设置的选项。 value (str): 指定选项的值。

    >>> m.setOption(mp.StrOption.MODEL_NAME, "diet_problem")
>>> m.setOption(mp.StrOption.SOLVER, "mindopt")
>>> m.setOption(mp.StrOption.SOLVER_OPTIONS, "num_threads= 2 print=0")
solve(self: maplpy.MAPL) → None

调用求解器求解模型。

>>> m.solve()
startCmd(self: list) → int

执行交互式命令行。

参数

args (list) – 命令行参数。

返回

返回值。

返回类型

int

>>> m.startCmd(["-h"])
write(self: maplpy.MAPL, dir_path: str = '') → None

写入模型文件到指定目录。

参数

dir_path (str) – 写入目录（默认为当前目录）。

>>> m.write("model/")
class maplpy.MaplModel

基类：pybind11_object

__init__(self: maplpy.MaplModel) → None
start_cmd(self: int, arg0: list) → int

执行交互式命令行，过期的接口

参数

args (list) – 命令行参数。

返回

返回值。

返回类型

int

>>> m.startCmd(["-h"])
class maplpy.Objective

基类：pybind11_object

Objective - 目标类用于绑定优化模型中的一个目标函数实体。通过 MAPL.getObjective 获取并绑定目标函数实体。 一个目标函数实体可能只是一个目标函数，也可能是一条多维目标函数，它是一组同名但是索引不同的目标函数集合。 通过该实体类可以获取目标函数的属性，如名称、表达式、最优解等。

>>> import maplpy as mp
>>> m = mp.MAPL()
>>> m.read("steel4.mpl")
>>> o = m.getObjective("Total_Profit")
>>> o.expr
>>> o.minimization
>>> m.optimize()
>>> o.value
__init__(*args, **kwargs)
__iter__(self: maplpy.Objective) → Iterator
__len__(self: maplpy.Objective) → int
__repr__(self: maplpy.Objective) → str
property exitcode

返回求解器退出码。

返回

求解器退出码。

返回类型

int

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].exitcode
property expr

当目标函数实体为一条具体目标函数时，返回目标函数表达式的字符串表示。

返回

目标函数表达式的字符串表示。

返回类型

str

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].expr
property is_scalar

当目标函数实体为一条具体目标函数时，返回具体目标函数是否为标量。

返回

目标函数是否为标量。

返回类型

bool

>>> objs = m.getObjective("Time")
>>> objs.is_scalar
property message

如果关闭了求解器日志，则重定向日志到此位置。

返回

求解器日志。

返回类型

str

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].message
property minimization

当目标函数实体为一条具体目标函数时，返回目标函数是否为最小化目标函数。

返回

目标函数是否为最小化目标函数。

返回类型

bool

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].minimization
property mstatus

当目标函数实体为一条具体目标函数时，返回目标函数的状态。

返回

目标函数的状态。

返回类型

str

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].mstatus
property name

当目标函数实体为一条具体目标函数时，返回目标函数名称。

返回

目标函数名称。

返回类型

str

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].name
property sstatus

返回求解器的状态。

返回

求解器的状态。

返回类型

str

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].sstatus
property value

当目标函数实体为一条具体目标函数时，返回根据当前变量值计算后，目标函数表达式的取值。

返回

目标函数表达式的值。

返回类型

float

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].value
property xref

当目标函数实体为一条具体目标函数时，返回目标函数相关的所有变量。

返回

目标函数相关的所有变量。

返回类型

list

>>> objs = m.getObjective("Total_Profit")
>>> objs[0].xref
class maplpy.StrOption

基类：pybind11_object

StrOption 枚举类用来指定需要配置的字符串类型选项。

Members:

MODEL_NAME :

MODEL_NAME 用于给模型命名。

>>> m.setOption(mp.StrOption.MODEL_NAME, "diet_problem")
SOLVER :

SOLVER 用于指定求解器。

>>> m.setOption(mp.StrOption.SOLVER, "mindopt")
SOLVER_OPTIONS :

SOLVER_OPTIONS 用于指定求解器选项。

>>> m.setOption(mp.StrOption.SOLVER_OPTIONS, "num_threads= 2 print=0")
SOLVER_PATH :

SOLVER_PATH 用于指定求解器路径。

>>> m.setOption(mp.StrOption.SOLVER_PATH, "/usr/local/bin;/usr/bin")
MODEL_NAME = <StrOption.MODEL_NAME: 1>
SOLVER = <StrOption.SOLVER: 2>
SOLVER_OPTIONS = <StrOption.SOLVER_OPTIONS: 4>
SOLVER_PATH = <StrOption.SOLVER_PATH: 3>
__init__(self: maplpy.StrOption, value: int) → None
__repr__(self: object) → str
property name
property value
class maplpy.Tuple

基类：pybind11_object

Tuple 类用于表示索引, 索引可以是整数, 字符串, 或者浮点数。 使用方法与 list 类似，不同的是，它需要先初始化大小，然后再赋值。 索引的作用是可以从一个变量，约束或目标实体中提取出单个变量，约束或目标。

>>> t = Tuple(3) # 初始化大小为 3
>>> t[0] = "xiao_ming"
>>> t[1] = 18
>>> t[2] = 175.0
>>> t
<Tuple with ("xiao_ming", 18, 175.0)>
>>> stu = m.getVariable("stu")
>>> xiao_ming = stu.find(t)
__getitem__(self: maplpy.Tuple, index: int) → Union[int, float, str]

获取 Tuple 类中的指定索引的值。 当类存在此内置函数时，意味着可以通过 [] 方法通过位置索引取值。

参数

index (int) – 索引位置。

返回

索引位置的值。

返回类型

int|float|str

>>> t = Tuple(("xiao_ming", 18, 175.0))
>>> t[0]
"xiao_ming"
__init__(*args, **kwargs)

Overloaded function.

  1. __init__(self: maplpy.Tuple, size: int) -> None

    初始化 Tuple 类。

    参数:

    size (int): Tuple 类的大小。

    >>> t = Tuple(3)

  2. __init__(self: maplpy.Tuple, values: List[Union[int, float, str]]) -> None

    初始化 Tuple 类。

    参数:

    tuple (tuple): Tuple 类的初始值。

    >>> t = Tuple(("xiao_ming", 18, 175.0))
__len__(self: maplpy.Tuple) → int

返回 Tuple 类的长度。 当类存在此内置函数时，意味着可以通过 len 方法获取 Tuple 类的长度。

返回

Tuple 类的长度。

返回类型

int

>>> t = Tuple(("xiao_ming", 18, 175.0))
>>> len(t)
__repr__(self: maplpy.Tuple) → str

返回 Tuple 类的字符串表示。 当类存在此内置函数时，意味着可以直接对类进行输出。

返回

Tuple 类的字符串表示。

返回类型

str

>>> t = Tuple(("xiao_ming", 18, 175.0))
>>> print(t)
<Tuple with ("xiao_ming", 18, 175.0)>
__setitem__(self: maplpy.Tuple, index: int, value: Union[int, float, str]) → None

设置 Tuple 类中的指定索引的值。 当类存在此内置函数时，意味着可以通过 [] 方法通过位置索引赋值。

参数

  • index (int) – 索引位置。

  • value (int|float|str) – 索引位置的值。

>>> t = Tuple(("xiao_ming", 18, 175.0))
>>> t[0] = "xiao_ming_new"
>>> t
<Tuple with ("xiao_ming_new", 18, 175.0)>
class maplpy.Variable

基类：pybind11_object

Variable - 变量类用于绑定优化模型中的一个决策变量实体。通过 MAPL.getVariable 获取并绑定决策变量实体。 一个决策变量实体可能只是一条决策变量，也可能是一条多维决策变量，它是一组同名但是索引不同的决策变量集合。 通过该实体类可以获取决策变量的属性，如名称、上下界、满足条件的表达式值等。

>>> vars = m.getVariable("Make")
>>> x.lb = 10
>>> x.ub = 20
>>> x.name = "x"
>>> m.optimize()
>>> x.value
__getitem__(self: maplpy.Variable, arg0: int) → maplpy.Variable

当决策变量实体为一个决策变量集合时，返回指定位置索引的具体决策变量。 当类存在此内置函数时，意味着可以通过 [] 方法通过位置索引取值。

参数

position (int) – 位置索引值。

返回

决策变量集合中的指定位置索引的具体决策变量。

返回类型

Variable

>>> vars = m.getVariable("Make")
>>> var = vars[1]
__init__(*args, **kwargs)
__iter__(self: maplpy.Variable) → Iterator

当决策变量实体为一个决策变量集合时，对决策变量集合进行迭代遍历。 当类存在此内置函数时，意味着可以通过 for in 方法进行迭代遍历。

>>> vars = m.getVariable("Make")
>>> for var in vars:
>>>     print(var.name)
__len__(self: maplpy.Variable) → int

当决策变量实体为一个决策变量集合时，返回决策变量集合的大小。 当类存在此内置函数时，意味着可以通过 len 方法获取决策变量集合的大小。

返回

决策变量集合的大小。

返回类型

int

>>> vars = m.getVariable("Make")
>>> len(vars)
__next__(self: mapl::Variable::iterator) → mapl::Variable::iterator
__repr__(self: maplpy.Variable) → str

返回决策变量集合的字符串表示。 当决策变量实体为一个决策变量集合时，返回决策变量集合的字符串表示。 当决策变量实体为一条具体决策变量时，返回具体决策变量的字符串表示。 当类存在此内置函数时，意味着可以直接对类进行输出。

返回

决策变量集合或决策变量的字符串表示形式。

返回类型

str

>>> vars = m.getVariable("Make")
>>> print(vars)
>>> for var in vars:
>>>     print(var)
find(self: maplpy.Variable, *args) → maplpy.Variable

当决策变量实体为一个决策变量集合时，返回指定 Tuple 索引的具体决策变量。

参数

index (Tuple) – Tuple 索引值。

返回

决策变量集合中的指定``Tuple``索引的具体决策变量。

返回类型

Variable

>>> vars = m.getVariable("Make")
>>> t = mp.Tuple(["plate"])
>>> var_plate = vars.find(t)
>>> var_bands = vars.find("bands")
fix(*args, **kwargs)

Overloaded function.

  1. fix(self: maplpy.Variable) -> maplpy.Variable

    当决策变量实体为一个具体决策变量时，固定当前决策变量值。

    >>> vars = m.getVariable("Make")
>>> vars[1].fix()

  2. fix(self: maplpy.Variable, value: float) -> maplpy.Variable

    当决策变量实体为一个具体决策变量时，固定当前决策变量值为指定值。

    参数:

    value (float): 指定值。

    >>> vars = m.getVariable("Make")
>>> vars[1].fix(5000)
property index

当决策变量实体为一条具体决策变量时，返回决策变量在模型中的索引。

返回

决策变量的索引。

返回类型

int

>>> vars = m.getVariable("Make")
>>> vars[1].index
property init

当决策变量实体为一条具体决策变量时，返回决策变量的初始值。

返回:

float: 决策变量的初始值。

>>> vars = m.getVariable("Make")
>>> vars[1].init
property integrality

当决策变量实体为一条具体决策变量时，返回决策变量的类型。

返回

决策变量的类型。

返回类型

Integrality

>>> vars = m.getVariable("Make")
>>> vars[1].integrality
property lb

当决策变量实体为一条具体决策变量时，返回决策变量的下界。

返回

决策变量的下界。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].lb
property lrc

当决策变量实体为一个具体决策变量时，返回当前决策变量值相对决策变量下界的改善量（差值）。

返回

决策变量值相对决策变量下界的改善量（差值）。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].lrc
property name

当决策变量实体为一条具体决策变量时，返回决策变量名称。

返回

决策变量名称。

返回类型

str

>>> vars = m.getVariable("Make")
>>> vars[1].name
property num_instances

当决策变量实体为一个决策变量集合时，返回决策变量集合中决策变量的数量。 也可以使用 len 方法获取决策变量集合的大小。

返回

决策变量集合中决策变量的数量。

返回类型

int

>>> vars = m.getVariable("Make")
>>> vars.num_instances
property rc

当决策变量实体为一个具体决策变量时，返回当前决策变量值相对决策变量上下界的最小改善量（最小差值）。

返回

决策变量值相对决策变量上下界的改善量（差值）。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].rc
setValue(self: maplpy.Variable, value: float) → maplpy.Variable

当决策变量实体为一个具体决策变量时，设置当前决策变量的值。

参数

value (float) – 指定值。

>>> vars = m.getVariable("Make")
>>> vars[1].setValue(2400)
property status

当决策变量实体为一个具体决策变量时，返回当前决策变量的状态（ in ：被使用； unused ：未使用）。

返回

决策变量的状态。

返回类型

str

>>> vars = m.getVariable("Make")
>>> vars[1].status
property ub

当决策变量实体为一条具体决策变量时，返回决策变量的上界。

返回

决策变量的上界。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].ub
unfix(self: maplpy.Variable) → maplpy.Variable

当决策变量实体为一个具体决策变量时，取消固定当前决策变量值。

>>> vars = m.getVariable("Make")
>>> vars[1].unfix()
property urc

当决策变量实体为一个具体决策变量时，返回当前决策变量值相对决策变量上界的改善量（差值）。

返回

决策变量值相对决策变量上界的改善量（差值）。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].urc
property value

当决策变量实体为一条具体决策变量时，返回根据当前变量值计算后，决策变量表达式的取值。

返回

决策变量表达式的值。

返回类型

float

>>> vars = m.getVariable("Make")
>>> vars[1].value