Method: mathopt.solveMathOptModel

求解输入模型并立即返回结果。如果不需要回调和增量，并且不需要跟踪求解进度，请使用此方式。

HTTP 请求

POST https://optimization.googleapis.com/v1/mathopt:solveMathOptModel

网址采用 gRPC 转码语法。

请求正文

请求正文中包含结构如下的数据：

JSON 表示法 
{
  "solverType": enum (SolverTypeProto),
  "model": {
    object (ModelProto)
  },
  "parameters": {
    object (SolveParametersProto)
  },
  "modelParameters": {
    object (ModelSolveParametersProto)
  }
}
字段
solverType

enum (SolverTypeProto)

可选。求解器类型，用于以数值方式解题。请注意，如果求解器不支持模型中的特定特征，优化程序将无法成功。
model

object (ModelProto)

必需。要解决的优化问题的数学表示法。
parameters

object (SolveParametersProto)

可选。用于控制单个求解的参数。系统会专门处理 enableOutput 参数。对于支持消息回调的求解器，将其设置为 true 会让服务器注册消息回调。生成的消息将在 SolveMathOptModelResponse.messages 中返回。对于其他求解器，将 enableOutput 设为 true 会导致错误。
modelParameters

object (ModelSolveParametersProto)

可选。用于控制特定于输入模型的单一求解的参数（如需了解与模型无关的参数，请参阅 SolveParametersProto）。

响应正文

MathOpt 中一元远程求解的响应。

如果成功，响应正文将包含结构如下的数据：

JSON 表示法 
{
  "result": {
    object (SolveResultProto)
  },
  "messages": [
    string
  ]
}
字段
result

object (SolveResultProto)

解析请求中的模型的输出说明。
messages[]

string

如果已使用 SolveParametersProto.enable_output ，这将包含支持消息回调的求解器的日志消息。

SolverTypeProto

MathOpt 支持的求解器。

枚举
SOLVER_TYPE_UNSPECIFIED
SOLVER_TYPE_GSCIP

解约束整数计划 (SCIP) 求解器（第三方）。

支持 LP、MIP 和非凸整数二次问题。但不会返回语言包的双数据。对于 LP，首选 GLOP。
SOLVER_TYPE_GUROBI

Gurobi 求解器（第三方）。

支持 LP、MIP 和非凸整数二次问题。通常是最快的选项，但具有特殊许可。
SOLVER_TYPE_GLOP

Google 的 Glop 求解器。

通过原始单工方法和双简单型方法支持 LP。
SOLVER_TYPE_CP_SAT

Google 的 CP-SAT 求解器。

支持所有变量均为整数且有界限（或隐含在 presolve 之后）的问题。提供实验性支持，用于重新调整规模并将涉及连续变量的问题进行离散化处理。
SOLVER_TYPE_PDLP

Google 的 PDLP 求解器。

支持 LP 和凸对角二次目标。使用一阶方法，而不是简单方法。可以解决非常大的问题。
SOLVER_TYPE_GLPK

GNU 线性编程套件 (GLPK)（第三方）。

支持 MIP 和 LP。

线程安全：GLPK 使用线程本地存储空间进行内存分配。因此，求解器实例在创建时必须在同一线程上销毁，否则 GLPK 将崩溃。除了用于创建求解器的线程之外，还可以从其他线程调用 Solver::Solve()，但 GLPK 并未记录该线程，因此应避免使用该线程。

在使用 presolver 解析 LP 时，仅当已找到最优解时，才会返回解（以及无约束射线）。否则，系统不会返回任何内容。如需了解详情，请参阅 glpk-5.0.tar.gz 提供的 glpk-5.0/doc/glpk.pdf 第 40 页。
SOLVER_TYPE_OSQP

运算符拆分二次程序 (OSQP) 求解器（第三方）。

使用线性约束条件以及线性或凸二次目标支持连续问题。使用一阶方法。
SOLVER_TYPE_ECOS

嵌入式圆锥求解器 (ECOS)（第三方）。

支持 LP 和 SOCP 问题。使用内部点方法（屏障）。
SOLVER_TYPE_SCS

分裂圆锥求解器 (SCS)（第三方）。

支持 LP 和 SOCP 问题。使用一阶方法。
SOLVER_TYPE_HIGHS

HiGHS 求解器（第三方）。

支持 LP 和 MIP 问题（凸 QP 未实现）。
SOLVER_TYPE_SANTORINI

MIP 求解器的 MathOpt 参考实现。

速度慢/不建议用于生产环境。不是语言包求解器（未返回双精度信息）。

ModelProto

优化问题。MathOpt 支持：- 具有可选有限边界的连续和整数决策变量。- 线性和二次目标（单个或多个目标），可以是最小化或最大化。- 多种约束条件类型，包括：* 线性约束条件 * 二次约束条件 * 二阶锥形约束条件 * 逻辑约束条件 >SOS1 和 SOS2 约束条件 >指示器限制条件

默认情况下，限制条件以“id-to-data”表示地图。不过，我们用更高效的“数组结构”来表示线性约束条件。格式。

JSON 表示法 
{
  "name": string,
  "variables": {
    object (VariablesProto)
  },
  "objective": {
    object (ObjectiveProto)
  },
  "auxiliaryObjectives": {
    string: {
      object (ObjectiveProto)
    },
    ...
  },
  "linearConstraints": {
    object (LinearConstraintsProto)
  },
  "linearConstraintMatrix": {
    object (SparseDoubleMatrixProto)
  },
  "quadraticConstraints": {
    string: {
      object (QuadraticConstraintProto)
    },
    ...
  },
  "secondOrderConeConstraints": {
    string: {
      object (SecondOrderConeConstraintProto)
    },
    ...
  },
  "sos1Constraints": {
    string: {
      object (SosConstraintProto)
    },
    ...
  },
  "sos2Constraints": {
    string: {
      object (SosConstraintProto)
    },
    ...
  },
  "indicatorConstraints": {
    string: {
      object (IndicatorConstraintProto)
    },
    ...
  }
}
字段
name

string
variables

object (VariablesProto)
objective

object (ObjectiveProto)

模型中的主要目标。
auxiliaryObjectives

map (key: string (int64 format), value: object (ObjectiveProto))

在多目标模型中使用的辅助目标。

映射键 ID 必须在 [0, max(int64)) 中。每个优先级以及每个非空名称都必须是唯一的，并且与主要 objective 不同。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
linearConstraints

object (LinearConstraintsProto)
linearConstraintMatrix

object (SparseDoubleMatrixProto)

线性约束条件的变量系数。

如果此限制条件涉及的变量被删除，系统会将其视为零。

要求：* LinearConstraintMatrix.row_ids 是 LinearConstraints.ids 的元素。* LinearConstraintMatrix.column_ids 是 variables.ids 的元素。* 未指定的矩阵条目为零。* LinearConstraintMatrix.values 都必须是有限的。
quadraticConstraints

map (key: string (int64 format), value: object (QuadraticConstraintProto))

模型中的二次约束条件。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
secondOrderConeConstraints

map (key: string (int64 format), value: object (SecondOrderConeConstraintProto))

模型中的二阶锥约束。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
sos1Constraints

map (key: string (int64 format), value: object (SosConstraintProto))

模型中的 SOS1 约束条件，限制了最多只能有一个 expression 为非零值。可选的 weights 条目是求解器用于实现（希望更快）收敛的实现细节。更具体地说，求解器可能会（也可能不会）使用这些权重来选择生成“均衡”的分支决策子节点。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
sos2Constraints

map (key: string (int64 format), value: object (SosConstraintProto))

模型中的 SOS2 约束条件，限制到最多有两个 expression 条目可以为非零值，并且它们在排序上必须相邻。如果未提供 weights，则此排序为它们在 expressions 列表中的线性排序；如果提供了 weights，则根据这些值以升序进行排序。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
indicatorConstraints

map (key: string (int64 format), value: object (IndicatorConstraintProto))

模型中的指标约束条件，如果为二进制“指标变量”，则会强制实施此约束条件则设置为 1，则使用“隐式约束”必须保持最新状态。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。

VariablesProto

如下所示，我们将“#variables”定义为= size(VariablesProto.ids)。

JSON 表示法 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "integers": [
    boolean
  ],
  "names": [
    string
  ]
}
字段
ids[]

string (int64 format)

必须是非负数，并且严格递增。不能使用 max(int64) 值。
lowerBounds[]

number

长度应等于 #variables，[-inf, inf) 中的值。
upperBounds[]

number

长度应等于 #variables，值在 (-inf, inf] 中。
integers[]

boolean

长度应等于 #variables。对于连续变量，值为 false；对于整数变量，值为 true。
names[]

string

如果未设置，则假定全部为空字符串。否则，其长度应等于 #variables。

所有非空名称必须互不相同。

ObjectiveProto

JSON 表示法 
{
  "maximize": boolean,
  "offset": number,
  "linearCoefficients": {
    object (SparseDoubleVectorProto)
  },
  "quadraticCoefficients": {
    object (SparseDoubleMatrixProto)
  },
  "name": string,
  "priority": string
}
字段
maximize

boolean

false 表示最小化，true 表示最大化
offset

number

必须为有限值，而不是 NaN。
linearCoefficients

object (SparseDoubleVectorProto)

ObjectiveProto 术语在决策变量中的线性。

要求：* LinearCoefficients.ids 是 VariablesProto.ids 的元素。* 未指定的 VariablesProto 对应于零。* linearCoefficients.values 必须全部为有限。* LinearCoefficients.values 可以为零，但这只是浪费空间。
quadraticCoefficients

object (SparseDoubleMatrixProto)

决策变量中属于二次方程的客观术语。

除了针对 SparseDoubleMatrixProto 消息的要求外，还需满足以下要求：* quadraticCoefficients.row_ids 的每个元素和 quadraticCoefficients.column_ids 的每个元素都必须是 VariablesProto.ids 的一个元素。* 矩阵必须为上三角形：对于每个 i，quadraticCoefficients.row_ids[i] <= quadraticCoefficients.column_ids[i]。

注意：* 未明确存储的字词的系数为零。* quadraticCoefficients.coefficients 的元素可以为零，但这只是浪费空间。
name

string

父级消息可能对此字段有唯一性要求；例如，请参见 ModelProto.objectives 和 AuxiliaryObjectivesUpdatesProto.new_objectives。
priority

string (int64 format)

对于多目标问题，应确定目标相对于其他目标的优先级（越低，越重要）。此值必须是非负数。此外，模型中的每个目标优先级在解题时都必须各不相同。此条件不会在 proto 级别进行验证，因此模型可能暂时具有具有相同优先级的目标。

SparseDoubleVectorProto

双精度向量的稀疏表示法。

JSON 表示法 
{
  "ids": [
    string
  ],
  "values": [
    number
  ]
}
字段
ids[]

string (int64 format)

必须（按递增顺序）排序，且所有元素各不相同。
values[]

number

长度必须与 ID 相同。不得包含 NaN。

SparseDoubleMatrixProto

双精度矩阵的稀疏表示法。

该矩阵以行 ID、列 ID 和系数的三元组形式存储。这三个向量必须相等。对于所有 i，元组 (rowIds[i], columnIds[i]) 应不同。条目必须按行主顺序排列。

JSON 表示法 
{
  "rowIds": [
    string
  ],
  "columnIds": [
    string
  ],
  "coefficients": [
    number
  ]
}
字段
rowIds[]

string (int64 format)
columnIds[]

string (int64 format)
coefficients[]

number

不得包含 NaN。

LinearConstraintsProto

如下所示，我们定义了“#线性约束条件”= size(LinearConstraintsProto.ids)。

JSON 表示法 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "names": [
    string
  ]
}
字段
ids[]

string (int64 format)

必须是非负数，并且严格递增。不能使用 max(int64) 值。
lowerBounds[]

number

长度应等于 #Linear 约束条件，[-inf, inf) 中的值。
upperBounds[]

number

长度应等于 #线性约束条件，值在 (-inf, inf] 中。
names[]

string

如果未设置，则假定全部为空字符串。否则，其长度应等于 #Linear 约束条件。

所有非空名称必须互不相同。

QuadraticConstraintProto

一个二次约束条件，格式为：lb <=sum{LinearTerms} +sum{quadraticTerms} <= ub。

如果此限制条件涉及的变量被删除，系统会将其视为零。

JSON 表示法 
{
  "linearTerms": {
    object (SparseDoubleVectorProto)
  },
  "quadraticTerms": {
    object (SparseDoubleMatrixProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string
}
字段
linearTerms

object (SparseDoubleVectorProto)

决策变量中的线性字词。

除了对 SparseDoubleVectorProto 消息的要求外，我们还要求：* LinearTerms.ids 是 VariablesProto.ids 的元素。* LinearTerms.values 必须全部为有限且不是 NaN。

注意：* 省略的变量 ID 对应的系数为零。* LinearTerms.values 可以为零，但会浪费空间。
quadraticTerms

object (SparseDoubleMatrixProto)

决策变量中二次方的项。

除了对 SparseDoubleMatrixProto 消息的要求外，我们还要求：* quadraticTerms.row_ids 的每个元素和 quadraticTerms.column_ids 的每个元素都必须是 VariablesProto.ids 的一个元素。* 矩阵必须为上三角形：对于每个 i，quadraticTerms.row_ids[i] <= quadraticTerms.column_ids[i]。

注意：* 未明确存储的字词的系数为零。* quadraticTerms.coefficients 的元素可以为零，但这只是浪费空间。
lowerBound

number

值必须在 [-inf, inf 中），且小于或等于 upperBound。
upperBound

number

值必须在 (-inf, inf] 中，并且必须大于或等于 lowerBound。
name

string

父级消息可能对此字段有唯一性要求；例如，请参阅 ModelProto.quadratic_constraints 和 QuadraticConstraintUpdatesProto.new_constraints。

SecondOrderConeConstraintProto

以下形式的单个二阶锥形约束条件：

||argumentsToNorm||_2 <= upperBound，

其中，upperBound 和 argumentsToNorm 的每个元素都是线性表达式。

如果此限制条件涉及的变量被删除，系统会将其视为零。

JSON 表示法 
{
  "upperBound": {
    object (LinearExpressionProto)
  },
  "argumentsToNorm": [
    {
      object (LinearExpressionProto)
    }
  ],
  "name": string
}
字段
upperBound

object (LinearExpressionProto)
argumentsToNorm[]

object (LinearExpressionProto)
name

string

父级消息可能对此字段有唯一性要求；例如，请参阅 ModelProto.second_order_cone_constraints 和 SecondOrderConeConstraintUpdatesProto.new_constraints。

LinearExpressionProto

线性表达式的稀疏表示法（变量的加权和加上常量偏移）。

JSON 表示法 
{
  "ids": [
    string
  ],
  "coefficients": [
    number
  ],
  "offset": number
}
字段
ids[]

string (int64 format)

变量的 ID。必须（按递增顺序）排序，且所有元素各不相同。
coefficients[]

number

长度必须与 ID 相同。值必须有限，不能为 NaN。
offset

number

必须为有限值，并且不能为 NaN。

SosConstraintProto

用于表示单个 SOS1 或 SOS2 约束条件的数据。

如果此限制条件涉及的变量被删除，系统会将其视为零。

JSON 表示法 
{
  "expressions": [
    {
      object (LinearExpressionProto)
    }
  ],
  "weights": [
    number
  ],
  "name": string
}
字段
expressions[]

object (LinearExpressionProto)

要应用 SOS 约束的表达式：* SOS1：最多一个元素采用非零值。* SOS2：最多两个元素采用非零值，并且在重复排序中它们必须相邻。
weights[]

number

空值或与表达式长度相同。如果为空，则默认权重为 1、2...。如果存在，则条目必须是唯一的。
name

string

父级消息可能对此字段有唯一性要求；例如，请参阅 ModelProto.sos1_constraints 和 SosConstraintUpdatesProto.new_constraints。

IndicatorConstraintProto

用于表示以下形式的单个指标约束条件的数据：Variable(indicatorId) = (activateOnZero ?0 : 1) ⇒ lowerBound <= 表达式 <= topBound。

如果此限制条件涉及的变量（指示器或显示在 expression 中的变量）被删除，系统会将其视为 0。特别是，删除指示器变量意味着，如果 activateOnZero 为 false，则指示符约束条件是空的；如果 activateOnZero 为 true，则相当于线性约束条件。

JSON 表示法 
{
  "activateOnZero": boolean,
  "expression": {
    object (SparseDoubleVectorProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string,
  "indicatorId": string
}
字段
activateOnZero

boolean

如果为 true，则如果指示器变量的值为 0，则必须具有隐含的约束条件。否则，如果指示器变量的值为 1，则必须具有隐含的约束条件。
expression

object (SparseDoubleVectorProto)

必须是与包含模型相关的有效线性表达式：* 在 SparseDoubleVectorProto 上声明的所有条件，* expression.values 的所有元素都必须是有限的，* expression.ids 是 VariablesProto.ids 的子集。
lowerBound

number

值必须在 [-inf, inf) 中；不能为 NaN。
upperBound

number

值必须为 (-inf, inf]；不能为 NaN。
name

string

父级消息可能对此字段有唯一性要求；例如，请参阅 ModelProto.indicator_constraints 和 IndicatorConstraintUpdatesProto.new_constraints。
indicatorId

string (int64 format)

与二进制变量对应的 ID，或未设置。如果未设置，系统会忽略指示器约束条件。如果设置，我们要求：* VariablesProto.integers[indicatorId] = true, * VariablesProto.lower_bounds[indicatorId] >= 0, * VariablesProto.upper_bounds[indicatorId] <= 1。MathOpt 不会验证这些条件，但如果不满足这些条件，则会导致求解器在求解时返回错误。

SolveParametersProto

用于控制单个求解的参数。

包含所有求解器通用的两个参数，例如timeLimit 以及特定求解器的参数，例如gscip。如果同时在通用字段和求解器专用字段中设置了某个值，则系统会使用求解器专用设置。

可选且未设置的通用参数或未指定值的枚举表示使用求解器默认值。

对于除正在使用的求解器之外的求解器，其特定参数会被忽略。

依赖于模型的参数（例如为每个变量设置分支优先级）在 ModelSolveParametersProto 中传递。

JSON 表示法 
{
  "timeLimit": string,
  "enableOutput": boolean,
  "lpAlgorithm": enum (LPAlgorithmProto),
  "presolve": enum (EmphasisProto),
  "cuts": enum (EmphasisProto),
  "heuristics": enum (EmphasisProto),
  "scaling": enum (EmphasisProto),
  "iterationLimit": string,
  "nodeLimit": string,
  "cutoffLimit": number,
  "objectiveLimit": number,
  "bestBoundLimit": number,
  "solutionLimit": integer,
  "threads": integer,
  "randomSeed": integer,
  "absoluteGapTolerance": number,
  "relativeGapTolerance": number,
  "solutionPoolSize": integer
}
字段
timeLimit

string (Duration format)

求解器在解题上应花费的最长时间（如未设置，则为无限制时间）。

此值不是硬性限制，求解时间可能会略高于此值。此参数会始终传递给底层求解器，而不会使用求解器默认值。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
enableOutput

boolean

允许输出求解器实现轨迹。这些轨迹的位置取决于求解器。对于 SCIP 和 Gurobi，这将是标准输出流。对于 Glop 和 CP-SAT，这将记录(INFO)。

请注意，如果求解器支持消息回调，并且用户为其注册回调，则此参数值将被忽略，并且不会输出任何跟踪记录。
lpAlgorithm

enum (LPAlgorithmProto)

用于解线性程序的算法。如果为 LP_ALGORITHM_UNSPECIFIED，则使用求解器默认算法。

对于不是线性程序，但线性编程是子程序的问题，求解器可以使用此值。例如：MIP 求解器通常仅将其用于根 LP 求解（否则，则使用双简单函数）。
presolve

enum (EmphasisProto)

请在启动主要算法之前努力简化问题，如果开始处理 EMPHASIS_UNSPECIFIED，则调整求解器默认工作量。
cuts

enum (EmphasisProto)

努力提高 LP 放松程度（仅限 MIP）或求解器的默认工作量（如果 EMPHASIS_UNSPECIFIED）。

注意：停用剪切可能会阻止回调有机会在 MIP_NODE 添加剪切，这种行为特定于求解器。
heuristics

enum (EmphasisProto)

努力寻找完整搜索程序（仅限 MIP）中遇到过的可行解决方案；如果 EMPHASIS_UNSPECIFIED，则使用求解器默认的工作水平。
scaling

enum (EmphasisProto)

努力重新缩放问题以提高数值稳定性，或求解器的默认工作量（如果 EMPHASIS_UNSPECIFIED）。
iterationLimit

string (int64 format)

基础算法的迭代限制（例如简单数据透视）。具体行为取决于所使用的求解器和算法，但通常可以确定求解限制（可能需要进一步配置，例如一个线程）。

通常受 LP、QP 和 MIP 求解器支持，但对于 MIP 求解器，另请参阅 nodeLimit。
nodeLimit

string (int64 format)

限制通过枚举搜索解决的子问题（例如分支和绑定）的数量。对于许多求解器，这可用于确定性地限制计算（可能需要进一步配置，例如一个线程）。

通常，对于 MIP 求解器，另请参阅 iterationLimit。
cutoffLimit

number

如果求解器可以证明没有原始解至少达到截止时间，就会提前停止。

在提前停止时，求解器会返回终止原因 NO_SOLUTION_FOUND 且限值为 CUTOFF，无需提供任何额外的解信息。如果没有早停法，对返回值没有影响。

如果您希望返回的解决方案的目标与截止时间完全相同，建议您使用公差。

如需了解详情以及与 bestBoundLimit 的比较，请参阅用户指南。
objectiveLimit

number

一旦找到至少这样好的解决方案，求解器就会立即停止运行，终止原因可行，并限制目标。
bestBoundLimit

number

一旦证明最佳边界至少达到这样的效果，求解器就会立即停止运行，终止原因为 FEASIBLE 或 NO_SOLUTION_FOUND，并限制 OBJECTIVE。

如需了解详情以及与 cutoffLimit 的比较，请参阅用户指南。
solutionLimit

integer

在找到这么多可行的解决方案后，求解器提前停止，终止原因可行，限制解决方案。如果设置，必须大于零。它通常用于让求解器停在找到的第一个可行解上。请注意，对于任何返回的解决方案，无法保证其目标值。

求解器返回的解通常不会超过解限值，但 MathOpt 不会强制执行该限制，另请参阅 b/214041169。

目前支持 Gurobi 和 SCIP，并且仅支持值为 1 的 CP-SAT。
threads

integer

如果设置，则必须大于等于 1。
randomSeed

integer

在底层求解器中生成伪随机数生成器的种子。请注意，所有求解器都使用伪随机数来选择诸如 LP 算法中的扰动之类的内容、用于平分法规则和启发式修正。改变此值会对求解器的行为产生显著影响。

请注意，虽然所有求解器都有种子的概念，但有效值取决于实际求解器。- Gurobi：[0:GRB_MAXINT]（自 Gurobi 9.0 开始，该值为 2x10^9）。- GSCIP：[0:2147483647]（MAX_INT、kint32max 或 2^31-1）。- GLOP：[0:2147483647]（同上）在任何情况下，求解器都会收到一个等于 MAX(0, MIN(MAX_VALID_VALUE_FOR_SOLVER, randomSeed)) 的值。
absoluteGapTolerance

number

MIP 求解器的绝对最优容限（主要）。

绝对 GAP 是以下两者之差的绝对值：* 找到的最佳可行解决方案的目标值 * 搜索产生的双边界。当绝对 GAP 达到 绝对 GapTolerance（若已设置）时，求解器就会停止，并返回 TERMINATION_REASON_OPTIMAL。

如果设置，则必须 >= 0。

另请参阅 relativeGapTolerance。
relativeGapTolerance

number

MIP 求解器的相对最佳公差（主要）。

相对 GAP 是绝对 GAP 的标准化版本（基于 绝对 GapTolerance 定义），其中归一化取决于求解器，例如：绝对 GAP 除以找到的最佳可行解决方案的目标值。

当相对 GAP 达到 relativeGapTolerance（若已设置）时，求解器便会停止，并返回 TERMINATION_REASON_OPTIMAL。

如果设置，则必须 >= 0。

另请参阅 绝对 GapTolerance。
solutionPoolSize

integer

在搜索时最多保留 solutionPoolSize 个解决方案。解池通常具有两项功能：(1) 对于可以返回多个解的求解器，限制会返回解的数量。(2) 有些求解器可能会使用解池中的解来运行启发式算法，因此更改此值可能会影响算法的路径。要强制求解器填充解池，请执行以下操作：对于 n 个最佳解决方案，需要进一步特定于求解器的配置。

LPAlgorithmProto

选择用于解线性程序的算法。

枚举
LP_ALGORITHM_UNSPECIFIED
LP_ALGORITHM_PRIMAL_SIMPLEX （原）单工方法。通常可以提供原始和双光解、对原始/双无界限问题的原始/双射线解，以及基础。
LP_ALGORITHM_DUAL_SIMPLEX 双简单方法。通常可以提供原始和双光解、对原始/双无界限问题的原始/双射线解，以及基础。
LP_ALGORITHM_BARRIER 屏障方法，通常也称为内点方法 (IPM)。通常可以同时提供原始解和双解。一些实现还针对无界限/不可行的问题生成光线。除非底层求解器执行“交叉”，否则不给出底数以单面体
LP_ALGORITHM_FIRST_ORDER 一种基于一阶方法的算法。这些方法通常会生成原始解决方案和双重解决方案，还可能会生成原始和/或双重不可行性证书。一阶方法提供的解决方案的准确率通常较低，因此用户应注意设置解决方案质量参数（例如公差）并验证解决方案。

EmphasisProto

解题过程中应用于可选任务的努力程度（有关使用信息，请参见 SolveParametersProto）。

强调用于按如下方式配置求解器功能：* 如果求解器不支持该功能，则只有“UNSPECIFIED”始终有效，任何其他设置通常都是“无效参数”错误（有些求解器可能也接受 OFF）。* 如果求解器支持 功能：- 当设置为 UNSPECIFIED 时，系统将使用基础默认值。- 如果无法关闭此功能，“关闭”将返回错误。- 如果默认情况下启用此功能，则求解器默认值通常会映射到 MEDIUM。- 如果地图项支持，LOW、MEDIUM、HIGH 和 VERY HIGH 不会产生错误，并会映射到其最佳匹配项。

枚举
EMPHASIS_UNSPECIFIED
EMPHASIS_OFF
EMPHASIS_LOW
EMPHASIS_MEDIUM
EMPHASIS_HIGH
EMPHASIS_VERY_HIGH

ModelSolveParametersProto

JSON 表示法 
{
  "variableValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "dualValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "reducedCostsFilter": {
    object (SparseVectorFilterProto)
  },
  "initialBasis": {
    object (BasisProto)
  },
  "solutionHints": [
    {
      object (SolutionHintProto)
    }
  ],
  "branchingPriorities": {
    object (SparseInt32VectorProto)
  }
}
字段
variableValuesFilter

object (SparseVectorFilterProto)

应用于由 PrimalSolutionProto 和 PrimalRayProto（PrimalSolutionProto.variable_values、PrimalRayProto.variable_values）中的变量键控的所有返回的稀疏容器的过滤器。

要求：*filterIds 是 VariablesProto.ids 的元素。
dualValuesFilter

object (SparseVectorFilterProto)

应用于由 DualSolutionProto 和 DualRay 中的线性约束条件键控的所有返回的稀疏容器（DualSolutionProto.dual_values、DualRay.dual_values）。

要求：*filterIds 是 LinearConstraints.ids 的元素。
reducedCostsFilter

object (SparseVectorFilterProto)

应用于由 DualSolutionProto 和 DualRay 中的变量键控的所有返回的稀疏容器（DualSolutionProto.reduced_costs、DualRay.reduced_costs）。

要求：*filterIds 是 VariablesProto.ids 的元素。
initialBasis

object (BasisProto)

温启动单纯 LP 求解器的可选初始基础。如果设置了此字段，则根据 validators/solution_validator.h 中的 ValidateBasis 对于当前 ModelSummary，该字段应有效。
solutionHints[]

object (SolutionHintProto)

可选的解决方案提示。如果底层求解器仅接受一个提示，则使用第一个提示。
branchingPriorities

object (SparseInt32VectorProto)

可选的分支优先级。值较高的变量会首先建立分支。未设置优先级的变量将获得求解器的默认优先级（通常为 0）。

要求：* branchingPriorities.values 必须是有限的。* branchingPriorities.ids 必须是 VariablesProto.ids 的元素。

SparseVectorFilterProto

此消息允许查询/设置 SparseXxxxVector 的特定部分。默认行为是不滤除任何内容。一种常见的用法是仅查询解决方案的某些部分（仅限非零值和/或一组手动选择的变量值）。

JSON 表示法 
{
  "skipZeroValues": boolean,
  "filterByIds": boolean,
  "filteredIds": [
    string
  ]
}
字段
skipZeroValues

boolean

对于 SparseBoolVectorProto “zero”为 false。
filterByIds

boolean

如果为 true，则仅返回与 filtersIds 中列出的 ID 对应的值。
filteredIds[]

string (int64 format)

当 filterByIds 为 true 时要使用的 ID 列表。当 filterByIds 为 false 时，必须为空。注意：如果此字段为空且 filterByIds 为 true，则表示您不想在结果中显示任何信息。

BasisProto

线性程序解的组合特征。

求解线性程序的简易方法始终会返回“基本可行解”可以用基础进行组合描述。基础会为每个变量和线性约束条件分配 BasisStatusProto。

例如：假设使用标准格式的语言包：min c * x s.t。A * x = b x >= 0，其变量多于限制条件且具有完整行排名 A。

让 n 是变量的数量，m 是线性约束条件的数量。按如下方式构建此问题的有效基础：* 所有约束条件的基础状态为“已修正”。* 选取 m 个变量，使 A 的列保持线性独立，并将状态指定为 BASIC。* 为其余 n - m 个变量指定状态 AT_LOWER。

此基础的基本解决方案是 A * x = b 的唯一解，它将状态 AT_LOWER 的所有变量固定到其下限（全部为零）。如果所得解还满足 x >= 0，则称为基本可行解。

JSON 表示法 
{
  "constraintStatus": {
    object (SparseBasisStatusVector)
  },
  "variableStatus": {
    object (SparseBasisStatusVector)
  },
  "basicDualFeasibility": enum (SolutionStatusProto)
}
字段
constraintStatus

object (SparseBasisStatusVector)

限制条件基础状态。

要求：* constraintStatus.ids 等于 LinearConstraints.ids。
variableStatus

object (SparseBasisStatusVector)

基于变量的状态。

要求：* constraintStatus.ids 等于 VariablesProto.ids。
basicDualFeasibility

enum (SolutionStatusProto)

这是 MathOpt 使用的一项高级功能，用于描述非最优 LP 解决方案的可行性（最优解决方案的状态将始终为 SOLUTION_STATUS_FEASIBLE）。

对于单端 LP，该值应等于相关双解决方案的可行性状态。对于双边 LP，在一些极端情况中可能会有所不同（例如，使用原始单纯解不完整）。

如果您通过 ModelSolveParametersProto.initial_basis 提供初始基础，则会忽略此值。它仅与 SolutionProto.basis 返回的基础相关。

SparseBasisStatusVector

基本状态向量的稀疏表示法。

JSON 表示法 
{
  "ids": [
    string
  ],
  "values": [
    enum (BasisStatusProto)
  ]
}
字段
ids[]

string (int64 format)

必须（按递增顺序）排序，且所有元素各不相同。
values[]

enum (BasisStatusProto)

长度必须与 ID 相同。

BasisStatusProto

LP 中变量/限制条件的状态。

枚举
BASIS_STATUS_UNSPECIFIED 表示无状态的保护值。
BASIS_STATUS_FREE 变量/约束条件是自由的（没有有限边界）。
BASIS_STATUS_AT_LOWER_BOUND 变量/约束条件已达下限（必须是有限的）。
BASIS_STATUS_AT_UPPER_BOUND 变量/约束条件已达上限（必须是有限的）。
BASIS_STATUS_FIXED_VALUE 变量/限制条件有完全相同的有限下限和上限。
BASIS_STATUS_BASIC 变量/约束条件是基本属性。

SolutionStatusProto

求解器声称的原始解或双解的可行性。

枚举
SOLUTION_STATUS_UNSPECIFIED 表示无状态的保护值。
SOLUTION_STATUS_UNDETERMINED 求解器未声明可行性状态。
SOLUTION_STATUS_FEASIBLE 求解器声称这个解决方案可行。
SOLUTION_STATUS_INFEASIBLE 求解器声称此解决方案不可行。

SolutionHintProto

建议的求解器起始解决方案。

MIP 求解器通常只需要原始信息 (variableValues)，而 LP 求解器需要原始信息和双信息 (dualValues)。

许多 MIP 求解器都支持：(1) 未指定所有变量的部分解或 (2) 不可行的解。在这些情况下，求解器通常求解子 MIP 以完成/更正提示。

求解器使用提示的方式（如果有的话）在很大程度上取决于求解器、问题类型和所用的算法。要确保提示有效，最可靠的方法是读取带有提示和不带提示的底层求解器日志。

单纯的 LP 求解器通常更喜欢初始基础而不是解提示（它们需要交叉，才能将提示转换为基本的可行解决方案）。

JSON 表示法 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "dualValues": {
    object (SparseDoubleVectorProto)
  }
}
字段
variableValues

object (SparseDoubleVectorProto)

可能的部分赋值给问题的原始变量。对于该子消息，不依赖于求解器的要求如下：*variableValues.ids 是 VariablesProto.ids 的元素。* variableValues.values 必须都是有限的。
dualValues

object (SparseDoubleVectorProto)

将值分配给问题的线性约束条件的（可能部分）分配。

要求：* dualValues.ids 是 LinearConstraintsProto.ids 的元素。* dualValues.values 必须都是有限的。

SparseInt32VectorProto

整数向量的稀疏表示法。

JSON 表示法 
{
  "ids": [
    string
  ],
  "values": [
    integer
  ]
}
字段
ids[]

string (int64 format)

应按升序进行排序，并且所有元素不能重复。
values[]

integer

长度必须与 ID 相同。

SolveResultProto

有关原始/双解/射线复杂情况的协定，请参阅 terminate_reasons.md，查看完整说明。

在最终确定合同之前，最好只检查是否存在解决方案/光照，而不是依赖终止原因。

JSON 表示法 
{
  "termination": {
    object (TerminationProto)
  },
  "solutions": [
    {
      object (SolutionProto)
    }
  ],
  "primalRays": [
    {
      object (PrimalRayProto)
    }
  ],
  "dualRays": [
    {
      object (DualRayProto)
    }
  ],
  "solveStats": {
    object (SolveStatsProto)
  }
}
字段
termination

object (TerminationProto)

求解器停止的原因。
solutions[]

object (SolutionProto)

未来求解器应实现解的一般顺序是按以下顺序进行排序：1.具有原始可行解决方案的解决方案，按最佳原始目标排序。2. 具有双可行解的解决方案，按最佳双目标排序（未知双目标最差）3.其余所有解决方案可按任意顺序退回。
primalRays[]

object (PrimalRayProto)

无界限原始改进或等效的双不可行证书的说明。通常为 TerulationReasonProtos UNBOUNDED 和 DUAL_INFEASIBLE 提供
dualRays[]

object (DualRayProto)

无界限双重改进或等效的原始不可行性证书的说明。通常用于 TeriationReasonProto INFEASIBLE 的。
solveStats

object (SolveStatsProto)

求解过程的统计信息，例如，运行时间、迭代。

TerminationProto

有关终止 Solve() 调用的所有信息。

JSON 表示法 
{
  "reason": enum (TerminationReasonProto),
  "limit": enum (LimitProto),
  "detail": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "objectiveBounds": {
    object (ObjectiveBoundsProto)
  }
}
字段
reason

enum (TerminationReasonProto)

当值为 TERMINATION_REASON_FEASIBLE 或 TERMINATION_REASON_NO_SOLUTION_FOUND 时，limit 中可提供更多信息，详情请参阅 limit。
limit

enum (LimitProto)

为 LIMIT_UNSPECIFIED，除非原因为 TERMINATION_REASON_FEASIBLE 或 TERMINATION_REASON_NO_SOLUTION_FOUND。并非所有求解器都能始终确定导致终止的限值，当无法确定原因时，请使用 LIMIT_UNDETERMINED。
detail

string

与终止相关的其他通常特定于求解器的信息。
problemStatus

object (ProblemStatusProto)

原始问题和双重问题的可行性状态。自 2023 年 7 月 18 日起，此消息可能会丢失。如果缺少，您可在 SolveResultProto.solve_stats 中找到 issueStatus。
objectiveBounds

object (ObjectiveBoundsProto)

最佳目标值的边界。自 2023 年 7 月 18 日起，此消息可能会丢失。如果缺失，请在 SolveResultProto.solve.stats.best_primal_bound 中找到 goalBounds.primal_bound，而 goalBounds.dual_bound 可在 SolveResultProto.solve.stats.best_dual_bound 中找到。

TerminationReasonProto

对 Solve() 的调用终止的原因。

枚举
TERMINATION_REASON_UNSPECIFIED
TERMINATION_REASON_OPTIMAL 已找到可证明的最佳解决方案（在数值公差范围内）。
TERMINATION_REASON_INFEASIBLE 原始问题没有可行的解决方案。
TERMINATION_REASON_UNBOUNDED 原始问题是可行的，可以沿着原始射线找到任意好解。
TERMINATION_REASON_INFEASIBLE_OR_UNBOUNDED 原始问题要么不可行，要么是没有界限的。有关问题状态的更多详细信息，请参阅 SolveStats.problem_status。请注意，此处可能会映射 Gurobi 的无界限状态。
TERMINATION_REASON_IMPRECISE

问题已通过上述任一标准（最优、不可行、无界限或 InfeasibleOrUnbounded）得到解决，但不符合一个或多个公差。存在一些原始/双解/射线，但它们不太可行，或者（如果问题几乎是最佳的）它们可能是最佳解决方案目标和最佳目标边界之间的差距。

用户仍然可以查询原始/双解/光线和解统计信息，但他们负责处理数值不精确问题。
TERMINATION_REASON_FEASIBLE 优化器达到了某种限制，并返回了初始可行解决方案。有关达到的限制类型的详细说明，请参阅 SolveResultProto.limit_detail。
TERMINATION_REASON_NO_SOLUTION_FOUND 优化器达到了某种限制，没有找到原始可行的解决方案。有关达到的限制类型的详细说明，请参阅 SolveResultProto.limit_detail。
TERMINATION_REASON_NUMERICAL_ERROR 算法已停止运行，因为它遇到了不可恢复的数字错误。没有可用的解决方案信息。
TERMINATION_REASON_OTHER_ERROR 该算法已停止运行，因为发生了上述状态之一未涵盖的错误。没有可用的解决方案信息。

LimitProto

当 Solve() 提前停止时，TeriationReasonProto FEASIBLE 或 NO_SOLUTION_FOUND（达到的具体限制）。

枚举
LIMIT_UNSPECIFIED 当我们不受任何限制（例如 TERMINATION_REASON_OPTIMAL）终止时，用作 null 值。
LIMIT_UNDETERMINED 底层求解器不会显示已达到上限。
LIMIT_ITERATION 迭代算法在进行最大迭代次数后停止（例如简单迭代或屏障迭代）。
LIMIT_TIME 该算法会在用户指定的计算时间后停止。
LIMIT_NODE 分支绑定算法已停止运行，因为它探索了分支绑定树中的最大节点数。
LIMIT_SOLUTION 由于找到了所需数量的解，该算法已停止运行。这通常用于 MIP，让求解器返回其遇到的第一个可行解。
LIMIT_MEMORY 由于内存不足，算法已停止运行。
LIMIT_CUTOFF 在运行求解器时，会有一个截断目标（例如设置了 SolveParameters.cutoff_limit），这表明用户不想要任何比该截止时间更差的解，因此该求解器得出结论，没有至少与截止时间一样好的解。通常不会提供进一步的解决方案信息。
LIMIT_OBJECTIVE 该算法停止运行，因为它找到的解或边界优于用户设置的限制（请参阅 SolveParameters.objective_limit 和 SolveParameters.best_bound_limit）。
LIMIT_NORM 算法停止运行，因为迭代通常变得过大。
LIMIT_INTERRUPTED 算法因中断信号或用户中断请求而停止。
LIMIT_SLOW_PROGRESS 算法已停止运行，因为它无法继续找出解决方案。
LIMIT_OTHER

由于上述限制未涵盖，算法已停止运行。请注意，如果原因无法确定，请使用 LIMIT_UNDETERMINED；如果原因已知，但不符合上述任何替代方案，则使用 LIMIT_OTHER。

TermissionProto.detail 可能包含有关此限制的其他信息。

ProblemStatusProto

求解器声称的原始问题及其二元（或持续放宽的二元）的可行性状态。求解器不需要返回声明的证书（例如，求解器可以声明原始可行性，而不返回原始可行解决方案）。这种合并状态可全面描述求解器关于所求解题的可行性和无限性的声明。例如：

  • 原始问题和双重问题的可行状态表示原始问题是可行的、有界限的，并且可能具有最佳解决方案（保证适用于没有非线性约束的问题）。
  • 原始可行和双不可行状态表示原始问题是无界限的（即具有任意好解的解决方案）。

请注意，双重不可行状态本身（即伴有无法确定的原始状态）并不意味着原初问题是没有界限的，因为我们可能同时出现这两个问题都是不可行的。此外，虽然原始可行状态和双重可行状态可能暗示存在最优解，但这并不能保证求解器确实已找到此类最优解。

JSON 表示法 
{
  "primalStatus": enum (FeasibilityStatusProto),
  "dualStatus": enum (FeasibilityStatusProto),
  "primalOrDualInfeasible": boolean
}
字段
primalStatus

enum (FeasibilityStatusProto)

原始问题的状态。
dualStatus

enum (FeasibilityStatusProto)

双重问题的状态（或持续放松的双重问题的状态）。
primalOrDualInfeasible

boolean

如果为 true，求解器声称原始问题或双重问题不可行，但不知道哪一种（或两者是否不可行）。仅当 primal_problem_status = dual_problem_status = kUn 做出“决定”时，才能为 true。当预处理确定没有问题的最佳解决方案（但无法确定问题是由于不可行和/或无界限性导致）时，通常需要这些额外信息。

FeasibilityStatusProto

求解器声明的问题可行性状态（求解器无需返回声明的证书）。

枚举
FEASIBILITY_STATUS_UNSPECIFIED 表示无状态的保护值。
FEASIBILITY_STATUS_UNDETERMINED 求解器未声明状态。
FEASIBILITY_STATUS_FEASIBLE 求解器声称这个问题是可行的。
FEASIBILITY_STATUS_INFEASIBLE 求解器声称这个问题不可行。

ObjectiveBoundsProto

最佳目标值的边界。

JSON 表示法 
{
  "primalBound": number,
  "dualBound": number
}
字段
primalBound

number

求解器声称，在求解器的原始可行性容限（参见下面的警告）范围内，最优值等于或优于 primalBound（较小值，最小化值大于 primalBound）。* 当求解器未声明具有此边界时，primalBound 是微不足道的（+inf 表示最小化， -inf 最大化）。* primalBound 可以比最佳原始可行解决方案的目标更接近最佳值。特别是，即使没有返回原始可行解，primalBound 可能也非常重要。警告：确切的说法是，存在一个原始解：* 在数值上可行（即在求解器公差之前可行），* 有一个目标值 primalBound。这种在数值上可行的解决方案可能不太可行，在这种情况下，primalBound 可能绝对优于最优值。将原始可行性公差转换为 primalBound 上的公差非常重要，尤其是在可行性公差相对较大时（例如，使用 PDLP 解决问题时）。
dualBound

number

求解器声称，当求解器未声明具有此类边界时，求解器声称最优值等于或更差（大于 dualBound 求最小化，小于最大化）达到或小于 dualBound 求解器双可行性容限（参见下面的警告）：* dualBound 是无关紧要的（-inf 用于最小化，+inf 最大化）。与 primalBound 类似，即使返回最佳值，某些求解器也可能会发生这种情况。MIP 求解器通常会报告边界，即使该边界不够精确。* 对于连续问题，dualBound 可能比最佳双可行解决方案的目标更接近最佳值。对于 MIP，dualBound 的第一个重要值之一通常是 MIP 的 LP 放宽的最佳值。* 在求解器容限范围内，dualBound 应比 primalBound 更好（较小，适合最小化，较大较大），适合求解器公差（请参阅下面的警告）。警告：* 对于连续问题，确切的说法是，存在一种双解：* 在数值上可行（即在求解器公差之前可行），* 具有一个目标值 dualBound。这种在数值上可行的解决方案可能不太可行，在这种情况下，dualBound 可能比最佳值和 primalBound 更差。与原始情况类似，将双可行性公差转换为 dualBound 上的公差非常重要，尤其是在可行性公差相对较大时。不过，有些求解器提供 dualBound 的更正版本，在数值上更安全。可以通过求解器的特定输出（例如，对于 PDLP，pdlp_output.convergence_information.corrected_dual_objective）访问此更正版本。* 对于 MIP 求解器，dualBound 可与双解关联，以实现某些连续放宽（例如 LP 放宽），但这通常是求解器的执行造成的复杂结果，并且通常比 LP 求解器报告的边界更不精确。

SolutionProto

解决方案中包含的内容取决于问题的类型和求解器。当前常见的模式是 1。MIP 求解器仅返回原始解。2. 单纯 LP 求解器通常会返回基础以及与此基础相关联的原始解和双解。3. 其他连续求解器通常会返回原始解和双解解，这些解以依赖于求解器的形式连接。

要求：* 必须至少设置一个字段；解决方案不能为空。

JSON 表示法 
{
  "primalSolution": {
    object (PrimalSolutionProto)
  },
  "dualSolution": {
    object (DualSolutionProto)
  },
  "basis": {
    object (BasisProto)
  }
}
字段
primalSolution

object (PrimalSolutionProto)
dualSolution

object (DualSolutionProto)
basis

object (BasisProto)

PrimalSolutionProto

一种优化问题的解决方案。

例如：设想一个简单的线性程序：min c * x s.t。A * x >= b x >= 0。初始解决方法是将值分配给 x。上述假设满足 A * x >= b 和 x >= 0 是可行的。在下面的消息 PrimalSolutionProto 中，variableValues 为 x 且 goalValue 为 c * x。

JSON 表示法 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "objectiveValue": number,
  "auxiliaryObjectiveValues": {
    string: number,
    ...
  },
  "feasibilityStatus": enum (SolutionStatusProto)
}
字段
variableValues

object (SparseDoubleVectorProto)

要求：*variableValues.ids 是 VariablesProto.ids 的元素。* variableValues.values 必须都是有限的。
objectiveValue

number

由底层求解器计算出的目标值。不能是无限或 NaN。
auxiliaryObjectiveValues

map (key: string (int64 format), value: number)

由底层求解器计算的辅助目标值。键必须是有效的辅助目标 ID。值不能是无穷大或 NaN。

包含一系列 "key": value 对的对象。示例：{ "name": "wrench", "mass": "1.3kg", "count": "3" }。
feasibilityStatus

enum (SolutionStatusProto)

根据底层求解器得出的解决方案的可行性状态。

DualSolutionProto

一种优化问题的双重解决方案。

例如：假设原始双对线性节目对：(Primal) (Dual) min c * x max b * y s.t.A * x >= b s.t.y * A + r = c x >= 0 y，r >= 0。二元解即为 (y, r) 对。如果它满足上述 (Dual) 的约束条件，它是可行的。

在以下消息中，y 为双值，r 为降低费用，b * y 为目标值。

JSON 表示法 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  },
  "feasibilityStatus": enum (SolutionStatusProto),
  "objectiveValue": number
}
字段
dualValues

object (SparseDoubleVectorProto)

要求：* dualValues.ids 是 LinearConstraints.ids 的元素。* dualValues.values 必须都是有限的。
reducedCosts

object (SparseDoubleVectorProto)

要求：*ReduceCosts.ids 是 VariablesProto.ids 的元素。* ReduceCosts.values 必须全部都是有限的。
feasibilityStatus

enum (SolutionStatusProto)

根据底层求解器得出的解决方案的可行性状态。
objectiveValue

number

PrimalRayProto

优化问题的无限改进方向；其作用是证明了优化问题双重可行性。

例如：设想一个简单的线性程序：min c * x s.t。A * x >= b x >= 0。原始射线是满足以下条件的 x：c * x <0 A * x >= 0 x >= 0。请注意，如果给定可行解决方案，则原始射线的任何正倍数加上该解决方案仍然可行，并且给出了更好的目标值。原始射线也证明了双重优化问题是不可行的。

在下面的 PrimalRay 消息中，variableValues 为 x。

JSON 表示法 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  }
}
字段
variableValues

object (SparseDoubleVectorProto)

要求：*variableValues.ids 是 VariablesProto.ids 的元素。* variableValues.values 必须都是有限的。

DualRayProto

对优化问题进行无限改进的方向；原始不可行性的证明。

例如：假设原始双对线性节目对：(Primal) (Dual) min c * x max b * y s.t.A * x >= b s.t.y * A + r = c x >= 0 y，r >= 0。双射线是满足以下参数的一对 (y, r)：b * y >0 y * A + r = 0 y, r >= 0。观察到，向双可行解添加 (y, r) 的正倍数既保持了双可行性，又改善了目标（证明二重是无界限的）。双射线也证明了原始问题是不可行的。

在下面的 DualRay 消息中，y 是 dualValues，r 是降低费用。

JSON 表示法 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  }
}
字段
dualValues

object (SparseDoubleVectorProto)

要求：* dualValues.ids 是 LinearConstraints.ids 的元素。* dualValues.values 必须都是有限的。
reducedCosts

object (SparseDoubleVectorProto)

要求：*ReduceCosts.ids 是 VariablesProto.ids 的元素。* ReduceCosts.values 必须全部都是有限的。

SolveStatsProto

JSON 表示法 
{
  "solveTime": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "simplexIterations": string,
  "barrierIterations": string,
  "firstOrderIterations": string,
  "nodeCount": string
}
字段
solveTime

string (Duration format)

已用的挂钟时间，由 math_opt 测量，大约是 Solver::Solve() 中的时间。注意：这不包括完成模型的构建工作。

该时长以秒为单位，最多包含九个小数位，以“s”结尾。示例："3.5s"。
problemStatus

object (ProblemStatusProto)

原始问题和双重问题的可行性状态。
simplexIterations

string (int64 format)
barrierIterations

string (int64 format)
firstOrderIterations

string (int64 format)
nodeCount

string (int64 format)