Method: mathopt.solveMathOptModel

Resuelve el modelo de entrada y muestra el resultado de una sola vez. Úsalo cuando no necesites devoluciones de llamada ni incrementalidad, ni hacer un seguimiento del progreso de una solución.

Solicitud HTTP

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

La URL usa la sintaxis de la transcodificación gRPC.

Cuerpo de la solicitud

El cuerpo de la solicitud contiene datos con la siguiente estructura:

Representación JSON 
{
  "solverType": enum (SolverTypeProto),
  "model": {
    object (ModelProto)
  },
  "parameters": {
    object (SolveParametersProto)
  },
  "modelParameters": {
    object (ModelSolveParametersProto)
  }
}
Campos
solverType

enum (SolverTypeProto)

Opcional. Tipo de solucionador para resolver numéricamente el problema. Ten en cuenta que si un solucionador no admite una función específica en el modelo, el procedimiento de optimización no será exitoso.
model

object (ModelProto)

Obligatorio. Representación matemática del problema de optimización que se debe resolver.
parameters

object (SolveParametersProto)

Opcional. Parámetros para controlar una sola resolución. El parámetro enableOutput se controla de manera específica. En el caso de los solucionadores que admiten devoluciones de llamada de mensajes, establecerlo en verdadero hará que el servidor registre una devolución de llamada de mensaje. Los mensajes resultantes se mostrarán enResolveMathOptModelResponse.messages. Para otros solucionadores, configurar enableOutput como verdadero para generar un error.
modelParameters

object (ModelSolveParametersProto)

Opcional. Son parámetros para controlar una sola resolución que son específicos del modelo de entrada (consulta Resolver parámetrosProto para conocer los parámetros independientes del modelo).

Cuerpo de la respuesta

Respuesta para una resolución remota unario en MathOpt.

Si se ejecuta correctamente, el cuerpo de la respuesta contendrá datos con la siguiente estructura:

Representación JSON 
{
  "result": {
    object (SolveResultProto)
  },
  "messages": [
    string
  ]
}
Campos
result

object (SolveResultProto)

Descripción del resultado de la resolución del modelo en la solicitud.
messages[]

string

Si se usó ResolverParametersProto.enable_output, contendrá mensajes de registro para los solucionadores que admiten devoluciones de llamadas de mensajes.

SolverTypeProto

Los solucionadores de problemas compatibles con MathOpt.

Enumeraciones
SOLVER_TYPE_UNSPECIFIED
SOLVER_TYPE_GSCIP

Solución de solucionador de programas de números enteros de restricciones (SCIP) (tercero).

Admite problemas cuadráticos de números enteros no convexos, LP y MIP. Sin embargo, no se muestran datos dobles para los LP. Prefiero GLOP para LP.
SOLVER_TYPE_GUROBI

Resolutor de Gurobi (terceros)

Admite problemas cuadráticos de números enteros no convexos, LP y MIP. Suele ser la opción más rápida, pero tiene licencias especiales.
SOLVER_TYPE_GLOP

Resolutor de Glop de Google

Admite LP con métodos simplex primarios y duales.
SOLVER_TYPE_CP_SAT

Solución de problemas de CP-SAT de Google.

Compatible con problemas en los que todas las variables son números enteros y delimitados (o se implica que son posteriores a presolve). Compatibilidad experimental para reescalar y discretizar problemas con variables continuas.
SOLVER_TYPE_PDLP

Solucionador de problemas PDLP de Google.

Admite LP y objetivos cuadráticos diagonales convexos. Usa métodos de primer orden en lugar de simplex. Puede resolver problemas muy grandes.
SOLVER_TYPE_GLPK

GNU Linear Programming Kit (GLPK) (tercero).

Admite MIP y LP.

Seguridad de subprocesos: GLPK usa almacenamiento local de subprocesos para las asignaciones de memoria. En consecuencia, las instancias de la herramienta de resolución se deben destruir en el mismo subproceso en el que se crean. De lo contrario, GLPK fallará. Parece correcto llamar a la función Resolverr::Solve() desde otro subproceso que no sea el que se usó para crearla, pero GLPK no la documenta y se debe evitar.

Cuando se resuelve un LP con el presolver, solo se devuelve una solución (y los rayos no delimitados) si se encuentra una solución óptima. De lo contrario, no se muestra nada. Consulta la página 40 de glpk-5.0/doc/glpk.pdf disponible en glpk-5.0.tar.gz para obtener más detalles.
SOLVER_TYPE_OSQP

El solucionador de problemas del programa cuadrática de división de operadores (OSQP) (tercero).

Admite problemas continuos con restricciones lineales y objetivos cuadráticos lineales o convexos. Usa un método de primer orden.
SOLVER_TYPE_ECOS

El solucionador de problemas cónicos incorporado (ECOS) (terceros).

Es compatible con problemas de LP y SOCP. Usa métodos de puntos internos (barrera).
SOLVER_TYPE_SCS

El solucionador cónico de división (SCS) (tercero).

Es compatible con problemas de LP y SOCP. Usa un método de primer orden.
SOLVER_TYPE_HIGHS

Servicio de resolución de HiGHS (terceros).

Soluciona problemas de LP y MIP (las QP convexas no están implementadas).
SOLVER_TYPE_SANTORINI

Es la implementación de referencia de MathOpt de un solucionador de MIP.

Es lenta o no se recomienda para la producción. No es un solucionador de problemas de LP (no se muestra información doble).

ModelProto

Un problema de optimización. MathOpt admite lo siguiente: variables de decisión continuas y de números enteros con límites finitos opcionales. - Objetivos lineales y cuadráticos (objetivos únicos o múltiples), minimizados o maximizados. - Una serie de tipos de restricciones, incluidas las siguientes: * Limitaciones lineales * Restricciones cuadráticas * Restricciones de conos de segundo orden * Restricciones lógicas > Restricciones de SOS1 y SOS2 > Limitaciones del indicador

De forma predeterminada, las restricciones se representan en “id-to-data”. Maps. Sin embargo, representamos restricciones lineales en una "struct-of-arrays" más eficiente. de un conjunto de datos tengan un formato común.

Representación 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)
    },
    ...
  }
}
Campos
name

string
variables

object (VariablesProto)
objective

object (ObjectiveProto)

El objetivo principal del modelo.
auxiliaryObjectives

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

Objetivos auxiliares para usar en modelos de varios objetivos.

Los IDs de clave de mapa deben estar en [0, max(int64)). Cada prioridad, y cada nombre que no esté vacío, debe ser único y también distinto del objective principal.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
linearConstraints

object (LinearConstraintsProto)
linearConstraintMatrix

object (SparseDoubleMatrixProto)

Los coeficientes variables para las restricciones lineales.

Si se borra una variable involucrada en esta restricción, se trata como si se hubiera establecido en cero.

Requisitos: * linearConstraintMatrix.row_ids son elementos de linearConstraints.ids. * linearConstraintMatrix.column_ids son elementos de variables.ids. * Las entradas de la matriz que no se especifican son cero. * Todos los valores de linearConstraintMatrix.values deben ser finitos.
quadraticConstraints

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

Restricciones cuadráticas en el modelo

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
secondOrderConeConstraints

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

Restricciones de cono de segundo orden en el modelo

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos1Constraints

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

Restricciones de SOS1 en el modelo, que limitan como máximo un expression puede ser distinto de cero. Las entradas opcionales weights son un detalle de implementación que usa el solucionador para converger más rápido (con suerte). En más detalle, los solucionadores pueden (o no) usar estos pesos para seleccionar decisiones de ramificación que produzcan “equilibrados” secundarios.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos2Constraints

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

Restricciones de SOS2 en el modelo, que limitan como máximo dos entradas de expression pueden ser distintas de cero, y deben ser adyacentes en su orden. Si no se proporciona un weights, este orden es su orden lineal en la lista expressions. si se presentan weights, el orden se toma con respecto a estos valores, en orden ascendente.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
indicatorConstraints

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

Restricciones del indicador en el modelo, que aplican eso, si se trata de una “variable indicadora” binaria se establece en uno, luego una "restricción implícita" debe contener.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

VariablesProto

Como se usa a continuación, definimos "#variables" = size(VariablesProto.ids).

Representación JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "integers": [
    boolean
  ],
  "names": [
    string
  ]
}
Campos
ids[]

string (int64 format)

Debe ser no negativa y estar estrictamente creciente. No se puede usar el valor max(int64).
lowerBounds[]

number

Debe tener una longitud igual a #variables, valores en [-inf, inf).
upperBounds[]

number

Debe tener una longitud igual a #variables, valores en (-inf, inf].
integers[]

boolean

Debe tener una longitud igual a #variables. El valor es falso para variables continuas y verdadero para variables de número entero.
names[]

string

Si no se establece, se supone que son todas cadenas vacías. De lo contrario, la longitud debería ser igual a #variables.

Todos los nombres que no estén vacíos deben ser distintos.

ObjectiveProto

Representación JSON 
{
  "maximize": boolean,
  "offset": number,
  "linearCoefficients": {
    object (SparseDoubleVectorProto)
  },
  "quadraticCoefficients": {
    object (SparseDoubleMatrixProto)
  },
  "name": string,
  "priority": string
}
Campos
maximize

boolean

falso es minimizar, verdadero es maximizar
offset

number

Debe ser finita y no un valor NaN.
linearCoefficients

object (SparseDoubleVectorProto)

Términos de ObjectiveProto que son lineales en las variables de decisión.

Requisitos: * Los linearCoefficients.ids son elementos de VariablesProto.ids. * VariablesProto no especificadas corresponden a cero. * Todos los valores linearCoefficients.values deben ser finitos. * linearCoefficients.values puede ser cero, pero esto solo desperdicia espacio.
quadraticCoefficients

object (SparseDoubleMatrixProto)

Términos objetivos que son cuadráticos en las variables de decisión.

Requisitos además de los de los mensajes SparseDoubleMatrixProto: * Cada elemento de quadraticCoefficients.row_ids y cada elemento de quadraticCoefficients.column_ids debe ser un elemento de VariablesProto.ids. * La matriz debe ser triangular superior: para cada i, quadraticCoefficients.row_ids[i] <= quadraticCoefficients.column_ids[i].

Notas: * Los términos que no se almacenan explícitamente tienen un coeficiente cero. * Los elementos de cuadráticosCoeficientes.coeficientes pueden ser cero, pero esto solo desperdicia espacio.
name

string

Es posible que los mensajes principales tengan requisitos de exclusividad para este campo. p.ej., consulta ModelProto.objectives y AuxiliaryObjectivesUpdatesProto.new_objectives.
priority

string (int64 format)

Para problemas de varios objetivos, la prioridad de este objetivo en relación con los demás (los valores más bajos son más importantes). Este valor no debe ser negativo. Además, cada prioridad objetiva en el modelo debe ser distinta en el momento de la resolución. Esta condición no se valida en el nivel del prototipo, por lo que es posible que los modelos tengan objetivos con la misma prioridad de forma temporal.

SparseDoubleVectorProto

Representación dispersa de un vector de dobles.

Representación JSON 
{
  "ids": [
    string
  ],
  "values": [
    number
  ]
}
Campos
ids[]

string (int64 format)

Debe ordenarse (en orden ascendente) con todos los elementos distintos.
values[]

number

Debe tener la misma longitud que los ID. Es posible que no contenga NaN.

SparseDoubleMatrixProto

Representación dispersa de una matriz de dobles.

La matriz se almacena como triples de ID de fila, ID de columna y coeficiente. Estos tres vectores deben tener la misma longitud. Para todos los i, la tupla (rowIds[i], columnIds[i]) debe ser diferente. Las entradas deben estar en orden mayor de fila.

Representación JSON 
{
  "rowIds": [
    string
  ],
  "columnIds": [
    string
  ],
  "coefficients": [
    number
  ]
}
Campos
rowIds[]

string (int64 format)
columnIds[]

string (int64 format)
coefficients[]

number

Es posible que no contenga NaN.

LinearConstraintsProto

Como se usa a continuación, definimos “#linear constraints” = size(LinearConstraintsProto.ids).

Representación JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "names": [
    string
  ]
}
Campos
ids[]

string (int64 format)

Debe ser no negativa y estar estrictamente creciente. No se puede usar el valor max(int64).
lowerBounds[]

number

Debe tener una longitud igual a #limitaciones lineales, valores en [-inf, inf).
upperBounds[]

number

Debe tener una longitud igual a #limitaciones lineales, valores en (-inf, inf].
names[]

string

Si no se establece, se supone que son todas cadenas vacías. De lo contrario, debe tener una longitud igual a las #restricciones lineales.

Todos los nombres que no estén vacíos deben ser distintos.

QuadraticConstraintProto

Una restricción cuadrática única con el siguiente formato: lb <= sum{linearTerms} + sum{quadraticTerms} <= ub

Si se borra una variable involucrada en esta restricción, se trata como si se hubiera establecido en cero.

Representación JSON 
{
  "linearTerms": {
    object (SparseDoubleVectorProto)
  },
  "quadraticTerms": {
    object (SparseDoubleMatrixProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string
}
Campos
linearTerms

object (SparseDoubleVectorProto)

Términos que son lineales en las variables de decisión.

Además de los requisitos de los mensajes SparseDoubleVectorProto, exigimos lo siguiente: * Los linearTerms.ids son elementos de VariablesProto.ids. * Todos los linearTerms.values deben ser finitos y no ser NaN.

Notas: * Los IDs de variables omitidos tienen un coeficiente de cero correspondiente. * linearTerms.values puede ser cero, pero esto solo desperdicia espacio.
quadraticTerms

object (SparseDoubleMatrixProto)

Términos que son cuadráticos en las variables de decisión.

Además de los requisitos de los mensajes SparseDoubleMatrixProto, exigimos lo siguiente: * Cada elemento de quadraticTerms.row_ids y de quadraticTerms.column_ids debe ser un elemento de VariablesProto.ids. * La matriz debe ser triangular superior: para cada i, quadraticTerms.row_ids[i] <= quadraticTerms.column_ids[i].

Notas: * Los términos que no se almacenan explícitamente tienen un coeficiente cero. * Los elementos de quadraticTerms.coefficients pueden ser cero, pero esto simplemente desperdicia espacio.
lowerBound

number

Debe tener un valor en [-inf, inf) y ser menor o igual que upperBound.
upperBound

number

Debe tener un valor en (-inf, inf] y ser mayor o igual que lowerBound.
name

string

Es posible que los mensajes principales tengan requisitos de exclusividad para este campo. p.ej., consulta ModelProto.quadratic_constraints y QuadraticConstraintsProto.new_constraints.

SecondOrderConeConstraintProto

Una única restricción de cono de segundo orden de la forma:

||argumentsToNorm||_2 <= upperBound,

donde upperBound y cada elemento de argumentsToNorm son expresiones lineales.

Si se borra una variable involucrada en esta restricción, se trata como si se hubiera establecido en cero.

Representación JSON 
{
  "upperBound": {
    object (LinearExpressionProto)
  },
  "argumentsToNorm": [
    {
      object (LinearExpressionProto)
    }
  ],
  "name": string
}
Campos
upperBound

object (LinearExpressionProto)
argumentsToNorm[]

object (LinearExpressionProto)
name

string

Es posible que los mensajes principales tengan requisitos de exclusividad para este campo. p.ej., consulta ModelProto.second_order_cone_constraints y SecondOrderConeConstraintUpdatesProto.new_constraints.

LinearExpressionProto

Una representación dispersa de una expresión lineal (una suma ponderada de variables, más un desplazamiento constante).

Representación JSON 
{
  "ids": [
    string
  ],
  "coefficients": [
    number
  ],
  "offset": number
}
Campos
ids[]

string (int64 format)

ID de variables. Debe ordenarse (en orden ascendente) con todos los elementos distintos.
coefficients[]

number

Debe tener la misma longitud que los ID. Los valores deben ser finitos y no pueden ser NaN.
offset

number

Debe ser finito y puede no ser NaN.

SosConstraintProto

Datos para representar una sola restricción de SOS1 o SOS2.

Si se borra una variable involucrada en esta restricción, se trata como si se hubiera establecido en cero.

Representación JSON 
{
  "expressions": [
    {
      object (LinearExpressionProto)
    }
  ],
  "weights": [
    number
  ],
  "name": string
}
Campos
expressions[]

object (LinearExpressionProto)

Las expresiones sobre las que se debe aplicar la restricción SOS: * SOS1: como máximo un elemento toma un valor distinto de cero. * SOS2: como máximo dos elementos tienen valores distintos de cero y deben ser adyacentes en el orden repetido.
weights[]

number

Vacío o de igual longitud que las expresiones. Si están vacíos, los pesos predeterminados son 1, 2, ... Si están presentes, las entradas deben ser únicas.
name

string

Es posible que los mensajes principales tengan requisitos de exclusividad para este campo. p.ej., consulta ModelProto.sos1_constraints y SosConstraintUpdatesProto.new_constraints.

IndicatorConstraintProto

Datos para representar una restricción de indicador única con el formato: Variable(indicatorId) = (activateOnZero ? 0 : 1) WARNING valor de límite inferior <= expresión <= Límite superior.

Si se borra una variable involucrada en esta restricción (ya sea el indicador o que aparece en expression), se trata como si se hubiera establecido en cero. En particular, borrar la variable del indicador significa que la restricción del indicador está vacía si activateOnZero es falsa y que es equivalente a una restricción lineal si activateOnZero es verdadero.

Representación JSON 
{
  "activateOnZero": boolean,
  "expression": {
    object (SparseDoubleVectorProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string,
  "indicatorId": string
}
Campos
activateOnZero

boolean

Si es verdadero, si la variable indicadora toma el valor 0, se debe mantener la restricción implícita. De lo contrario, si la variable del indicador toma el valor 1, se debe mantener la restricción implícita.
expression

object (SparseDoubleVectorProto)

Debe ser una expresión lineal válida con respecto al modelo que lo contiene: * Todas las condiciones indicadas en SparseDoubleVectorProto. * Todos los elementos de expression.values deben ser finitos, * expression.ids son un subconjunto de VariablesProto.ids.
lowerBound

number

Debe tener un valor en [-inf, inf); no puede ser NaN.
upperBound

number

Debe tener un valor en (-inf, inf]; no puede ser NaN.
name

string

Es posible que los mensajes principales tengan requisitos de exclusividad para este campo. p.ej., consulta ModelProto.indicator_constraints y IndicatorConstraintUpdatesProto.new_constraints.
indicatorId

string (int64 format)

Un ID que corresponde a una variable binaria o no está establecido. Si no se establece, se ignora la restricción del indicador. Si se configura, exigimos lo siguiente: * VariablesProto.integers[indicatorId] = true, * VariablesProto.lower_bounds[indicatorId] >= 0, * VariablesProto.upper_bounds[indicatorId] <= 1. MathOpt no valida estas condiciones, pero, si no se cumplen, el agente de resolución mostrará un error luego de resolverla.

SolveParametersProto

Parámetros para controlar una sola resolución.

Contiene ambos parámetros comunes a todos los solucionadores, p.ej., timeLimit y los parámetros para un solucionador específico, p.ej., gscip. Si se establece un valor en el campo común y específico de la resolución, se usa la configuración específica de la herramienta.

Los parámetros comunes que son opcionales y no establecidos, o una enumeración con valor no especificado indican que se usa el valor predeterminado de la resolución.

Se ignoran los parámetros específicos de resolución que no sean el que está en uso.

Los parámetros que dependen del modelo (p.ej., se establece la prioridad de ramificación para cada variable) se pasan a ModelSolveParametersProto.

Representación 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
}
Campos
timeLimit

string (Duration format)

Tiempo máximo que un solucionador de problemas debería dedicar al problema (o infinito si no se establece).

Este valor no es un límite estricto, el tiempo de resolución puede superarlo ligeramente. Este parámetro siempre se pasa al agente de resolución subyacente; no se usa el valor predeterminado de la herramienta.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".
enableOutput

boolean

Habilita la impresión de registros de implementación del solucionador de problemas. La ubicación de esos seguimientos depende del solucionador. Para SCIP y Gurobi, estos serán los flujos de salida estándar. Para Glop y CP-SAT, se mostrará el estado LOG(INFO).

Ten en cuenta que si la herramienta de resolución admite la devolución de llamada de mensajes y el usuario registra una devolución de llamada para ella, se ignora este valor del parámetro y no se imprimen registros.
lpAlgorithm

enum (LPAlgorithmProto)

Es el algoritmo para resolver un programa lineal. Si es LP_ALGORITHM_UNSPECIFIED, usa el algoritmo predeterminado del solucionador.

Para problemas que no son programas lineales, pero en los que la programación lineal es una subrutina, los solucionadores pueden usar este valor. P.ej., Por lo general, los solucionadores de MIP usarán esto solo para la resolución del LP raíz (de lo contrario, usarán doble simplex).
presolve

enum (EmphasisProto)

Esfuerzo para simplificar el problema antes de iniciar el algoritmo principal, o el nivel de esfuerzo predeterminado del solucionador si está en Estás con un valor Hangouts_UNSPECIFIED.
cuts

enum (EmphasisProto)

Esfuerzo para lograr un mayor nivel de relajación del LP (solo MIP) o el nivel de esfuerzo predeterminado del solucionador si se encuentra en Estás con un nivel de esfuerzo menor (****)_UNSPECIFIED.

NOTA: Si inhabilitas los cortes, es posible que las devoluciones de llamada no puedan agregar cortes en MIP_NODE. Este comportamiento es específico del solucionador.
heuristics

enum (EmphasisProto)

Esfuerzo para encontrar soluciones posibles más allá de las que se encuentran en el procedimiento de búsqueda completo (solo MIP) o el nivel de esfuerzo predeterminado del solucionador, si es EMPHASIS_UNSPECIFIED.
scaling

enum (EmphasisProto)

Esfuerzo para reescalar el problema para mejorar la estabilidad numérica o el nivel de esfuerzo predeterminado del solucionador si es EMPHASIS_UNSPECIFIED.
iterationLimit

string (int64 format)

Límite de las iteraciones del algoritmo subyacente (p.ej., pivotes simplex). El comportamiento específico depende del solucionador y del algoritmo utilizado, pero a menudo puede proporcionar un límite de resolución determinista (puede que se necesite más configuración, p.ej., un subproceso).

Por lo general, es compatible con los solucionadores de LP, QP y MIP, pero, para los solucionadores de MIP, consulta también nodeLimit.
nodeLimit

string (int64 format)

Límite en la cantidad de subproblemas resueltos en la búsqueda enumerativa (p.ej., rama y límite). Para muchos solucionadores, esto se puede usar para limitar el procesamiento de manera determinista (puede que se necesite más configuración, p.ej., un subproceso).

Por lo general, para los solucionadores de MIP, consulta también iterationLimit.
cutoffLimit

number

El solucionador se detiene antes si puede demostrar que no hay soluciones básicas que sean tan buenas como el corte.

En una interrupción anticipada, el solucionador muestra el motivo de finalización NO_SOLUTION_FOUND y con el límite CUTOFF, y no es necesario proporcionar información adicional sobre la solución. No tiene ningún efecto en el valor que se muestra si no hay una parada anticipada.

Se recomienda que uses una tolerancia si deseas que se devuelvan soluciones cuyo objetivo sea exactamente igual al límite.

Consulta la guía del usuario para obtener más detalles y una comparación con bestBoundLimit.
objectiveLimit

number

El solucionador se detiene antes en cuanto encuentra una solución por lo menos así, con un motivo de finalización FEASIBLE y un OBJETIVO de límite.
bestBoundLimit

number

La resolución se detiene antes en cuanto demuestra que el mejor límite es al menos así, con motivo de rescisión FEASIBLE o NO_SOLUTION_FOUND y límite OBJETIVO.

Consulta la guía del usuario para obtener más detalles y una comparación con cutoffLimit.
solutionLimit

integer

La resolución se detiene temprano después de encontrar esta gran cantidad de soluciones posibles, con un motivo de rescisión FEASIBLE y limitar la SOLUCIÓN. Debe ser mayor que cero si se configura. A menudo, se usa para que el solucionador se detenga en la primera solución factible encontrada. Ten en cuenta que no hay garantía sobre el valor objetivo para ninguna de las soluciones mostradas.

Por lo general, los solucionadores no mostrarán más soluciones que el límite de soluciones, pero MathOpt no aplica esto (consulta también b/214041169).

Actualmente, se admite para Gurobi y SCIP, y solo para CP-SAT con valor 1.
threads

integer

Si se configura, debe ser >= 1.
randomSeed

integer

Valor inicial del generador de números pseudoaleatorio en el solucionador subyacente. Ten en cuenta que todos los solucionadores usan números pseudoaleatorios para seleccionar elementos como perturbación en el algoritmo LP, reglas de ruptura de empates y correcciones heurísticas. La variación en esto puede tener un impacto notable en el comportamiento de la resolución.

Aunque todos los solucionadores tienen un concepto de valor inicial, ten en cuenta que los valores válidos dependen del resultado real. - Gurobi: [0:GRB_MAXINT] (que a partir de Gurobi 9.0 es 2x10^9). - GSCIP: [0:2147483647] (que es MAX_INT, kint32max o 2^31-1). - GLOP: [0:2147483647] (igual que más arriba). En todos los casos, la resolución recibirá un valor igual a: MAX(0, MIN(MAX_VALID_VALUE_FOR_SOLVER, randomSeed)).
absoluteGapTolerance

number

Una tolerancia de optimización absoluta (principalmente) para los solucionadores de MIP.

El GAP absoluto es el valor absoluto de la diferencia entre: * el valor objetivo de la mejor solución posible encontrada y * el límite doble producido por la búsqueda. El solucionador puede detenerse una vez que el GAP absoluto tenga, como máximo, la tolerancia GapTolerance absoluta (si se establece) y mostrar TERMINATION_REASON_OPTIMAL.

Debe ser mayor o igual que 0 si se configura.

Consulta también RelativeGapTolerance.
relativeGapTolerance

number

Una tolerancia de optimización relativa (principalmente) para los solucionadores de MIP.

El GAP relativo es una versión normalizada del GAP absoluto (definido en la tolerancia absoluta de la GAP), en la que la normalización depende del solucionador, p.ej., GAP absoluto dividido por el valor objetivo de la mejor solución posible encontrada.

La herramienta de resolución puede detenerse una vez que el GAP relativo tenga, como máximo, una tolerancia GapTolerance relativa (si se establece) y mostrar TERMINATION_REASON_OPTIMAL.

Debe ser mayor o igual que 0 si se configura.

Consulta también la absorción absoluta de GapTolerance.
solutionPoolSize

integer

Conservar hasta solutionPoolSize soluciones mientras realizas búsquedas. Por lo general, el grupo de soluciones tiene dos funciones: (1) para los solucionadores que pueden mostrar más de una solución, esto limita la cantidad de soluciones que se mostrarán. (2) Algunos solucionadores pueden ejecutar heurísticas con soluciones del grupo de soluciones, por lo que cambiar este valor puede afectar la ruta del algoritmo. Para forzar al solucionador a que llene el grupo de soluciones, p.ej., con las mejores soluciones, requiere una configuración específica de resolución adicional.

LPAlgorithmProto

Selecciona un algoritmo para resolver programas lineales.

Enumeraciones
LP_ALGORITHM_UNSPECIFIED
LP_ALGORITHM_PRIMAL_SIMPLEX Método simplex (primal) Por lo general, puede proporcionar soluciones primarias y duales, rayos primarios/dobles para problemas primarios/duales no delimitados y una base.
LP_ALGORITHM_DUAL_SIMPLEX El método doble simplex. Por lo general, puede proporcionar soluciones primarias y duales, rayos primarios/dobles para problemas primarios/duales no delimitados y una base.
LP_ALGORITHM_BARRIER El método de barrera, también comúnmente llamado método de punto interior (IPM). Por lo general, puede ofrecer soluciones primarias y duales. Algunas implementaciones también pueden producir rayos en problemas no delimitados o inviables. No se proporciona una base, a menos que el solucionador subyacente realice un “combinación” y termina con simplex.
LP_ALGORITHM_FIRST_ORDER Algoritmo basado en un método de primer orden. Por lo general, estas producirán soluciones primarias y duales, y potencialmente también certificados de inviabilidad primaria o doble. Los métodos de primer orden generalmente proporcionarán soluciones con menor precisión, por lo que los usuarios deben tener cuidado de establecer parámetros de calidad de la solución (p.ej., tolerancias) y validar las soluciones.

EmphasisProto

Nivel de esfuerzo aplicado a una tarea opcional durante la resolución (consulta ChooseParametersProto para obtener información sobre su uso).

El énfasis se usa para configurar una función de solucionador de problemas de la siguiente manera: * Si un solucionador de problemas no admite la función, solo UNSPECIFIED siempre será válido. Cualquier otro parámetro de configuración suele generar un error de argumento no válido (algunos solucionadores también pueden aceptar el estado OFF). * Si el solucionador admite la función: cuando se establece en UNSPECIFIED, se usa el valor predeterminado subyacente. - Si no se puede desactivar la función, si la desactivas, se mostrará un error. - Si la función está habilitada de forma predeterminada, la configuración predeterminada del solucionador se suele asignar a MEDIUM. - Si la función es compatible, las opciones LOW, MEDIUM, HIGH y MUY HIGH nunca mostrarán un error y asignarán su mejor coincidencia.

Enumeraciones
EMPHASIS_UNSPECIFIED
EMPHASIS_OFF
EMPHASIS_LOW
EMPHASIS_MEDIUM
EMPHASIS_HIGH
EMPHASIS_VERY_HIGH

ModelSolveParametersProto

Representación JSON 
{
  "variableValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "dualValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "reducedCostsFilter": {
    object (SparseVectorFilterProto)
  },
  "initialBasis": {
    object (BasisProto)
  },
  "solutionHints": [
    {
      object (SolutionHintProto)
    }
  ],
  "branchingPriorities": {
    object (SparseInt32VectorProto)
  }
}
Campos
variableValuesFilter

object (SparseVectorFilterProto)

El filtro que se aplica a todos los contenedores dispersos que se muestran como claves por variables en PrimalSolutionProto y PrimalRayProto (PrimalSolutionProto.variable_values, PrimalRayProto.variable_values).

Requisitos: * Los IDs son elementos de VariablesProto.ids.
dualValuesFilter

object (SparseVectorFilterProto)

Es el filtro que se aplica a todos los contenedores dispersos que se muestran como claves por restricciones lineales en DualSolutionProto y DualRay (DualSolutionProto.dual_values, DualRay.dual_values).

Requisitos: * Los IDs son elementos de LinearConstraints.ids.
reducedCostsFilter

object (SparseVectorFilterProto)

Es el filtro que se aplica a todos los contenedores dispersos que se muestran como claves por variables en DualSolutionProto y DualRay (DualSolutionProto.reduced_costs, DualRay.reduced_costs).

Requisitos: * Los IDs son elementos de VariablesProto.ids.
initialBasis

object (BasisProto)

Base inicial opcional para solucionadores de problemas de LP simplex de inicio semicaliente. Si se configura, se espera que sea válido de acuerdo con ValidateBasis en validators/solution_validator.h para el ModelSummary actual.
solutionHints[]

object (SolutionHintProto)

Sugerencias de soluciones opcionales. Si el solucionador subyacente solo acepta una sugerencia, se usa la primera.
branchingPriorities

object (SparseInt32VectorProto)

Prioridades de ramificación opcionales. Las variables con valores más altos se ramificarán primero. Las variables para las que no se establecen prioridades obtienen la prioridad predeterminada del solucionador (generalmente cero).

Requisitos: * BranchingPriorities.values debe ser finito. * branchingPriorities.ids deben ser elementos de VariablesProto.ids.

SparseVectorFilterProto

Este mensaje permite consultar o configurar partes específicas de un SparseXxxxVector. El comportamiento predeterminado es no filtrar nada. Un uso común es consultar solo las partes de las soluciones (solo valores distintos de cero o solo un conjunto de valores de variables seleccionados).

Representación JSON 
{
  "skipZeroValues": boolean,
  "filterByIds": boolean,
  "filteredIds": [
    string
  ]
}
Campos
skipZeroValues

boolean

Para SparseBoolVectorProto “zero” es false.
filterByIds

boolean

Cuando es verdadero, muestra solo los valores correspondientes a los IDs enumerados en filterIds.
filteredIds[]

string (int64 format)

La lista de IDs que se deben usar cuando filterByIds es verdadero. Debe estar vacío cuando filterByIds es falso. NOTA: Si este campo está vacío y filterByIds es verdadero, estás diciendo que no quieres que se muestre información en el resultado.

BasisProto

Es una caracterización combinatoria de una solución para un programa lineal.

El método simplex para resolver programas lineales siempre devuelve una "solución factible básica" que se puede describir de forma combinatoria con una base. Una base asigna un BasisStatusProto para cada variable y restricción lineal.

P.ej., considera un formato estándar de página de destino: min c * x s.t. A * x = b x >= 0 que tiene más variables que restricciones y que tiene el rango de filas completo A.

Supongamos que n es el número de variables y m el número de restricciones lineales. Una base válida para este problema puede construirse de la siguiente manera: * Todas las restricciones tendrán el estado de base FIXED. * Elige m variables de modo que las columnas de A sean linealmente independientes y asígnales el estado BASIC. * Asigna el estado AT_LOWER a las variables n - m restantes.

La solución básica para esta base es la solución única de A * x = b que tiene todas las variables con el estado AT_LOWER fijado en sus límites inferiores (todo en cero). La solución resultante se denomina solución factible básica si también satisface x >= 0.

Representación JSON 
{
  "constraintStatus": {
    object (SparseBasisStatusVector)
  },
  "variableStatus": {
    object (SparseBasisStatusVector)
  },
  "basicDualFeasibility": enum (SolutionStatusProto)
}
Campos
constraintStatus

object (SparseBasisStatusVector)

Estado de la base de restricción.

Requisitos: * constraintStatus.ids es igual a LinearConstraints.ids.
variableStatus

object (SparseBasisStatusVector)

Estado de base variable.

Requisitos: * constraintStatus.ids es igual a VariablesProto.ids.
basicDualFeasibility

enum (SolutionStatusProto)

Esta es una función avanzada que utiliza MathOpt para caracterizar la viabilidad de soluciones de LP que no son óptimas (las soluciones óptimas siempre tendrán el estado SOLUTION_STATUS_FEASIBLE).

En el caso de los LP unilaterales, debe ser igual al estado de viabilidad de la solución dual asociada. Para los LP bilaterales, puede ser diferente en algunos casos extremos (p.ej., soluciones incompletas con simplex primario).

Si proporcionas una base inicial a través de ModelSolveParametersProto.initial_basis, este valor se ignora. Solo es relevante para la base que muestra SolutionProto.basis.

SparseBasisStatusVector

Representación dispersa de un vector de estados de base.

Representación JSON 
{
  "ids": [
    string
  ],
  "values": [
    enum (BasisStatusProto)
  ]
}
Campos
ids[]

string (int64 format)

Debe ordenarse (en orden ascendente) con todos los elementos distintos.
values[]

enum (BasisStatusProto)

Debe tener la misma longitud que los ID.

BasisStatusProto

Estado de una variable o restricción en función del LP.

Enumeraciones
BASIS_STATUS_UNSPECIFIED Valor de Guard que indica que no hay estado.
BASIS_STATUS_FREE La variable o restricción es libre (no tiene límites finitos).
BASIS_STATUS_AT_LOWER_BOUND La variable o restricción se encuentra en su límite inferior (que debe ser finito).
BASIS_STATUS_AT_UPPER_BOUND La variable o restricción se encuentra en su límite superior (que debe ser finito).
BASIS_STATUS_FIXED_VALUE La variable o restricción tiene límites inferiores y superiores finitos.
BASIS_STATUS_BASIC La variable o restricción es básica.

SolutionStatusProto

Viabilidad de una solución primaria o doble, según lo afirma el solucionador

Enumeraciones
SOLUTION_STATUS_UNSPECIFIED Valor de Guard que indica que no hay estado.
SOLUTION_STATUS_UNDETERMINED La herramienta de resolución no reclama un estado de viabilidad.
SOLUTION_STATUS_FEASIBLE El solucionador indica que la solución es factible.
SOLUTION_STATUS_INFEASIBLE El solucionador indica que la solución es inviable.

SolutionHintProto

Una solución inicial sugerida para la resolución.

Por lo general, los solucionadores de MIP solo quieren información primaria (variableValues), mientras que los solucionadores de LP requieren información primaria y dual (dualValues).

Muchos solucionadores de MIP pueden trabajar con (1) soluciones parciales que no especifican todas las variables o (2) soluciones inviables. En estos casos, los solucionadores suelen resolver una MIP secundaria para completar o corregir la sugerencia.

La manera en que el solucionador usa la sugerencia, si es que lo hace, depende en gran medida del solucionador, del tipo de problema y del algoritmo que se usa. La forma más confiable de asegurarte de que tu sugerencia tenga efecto es leer los registros subyacentes de solucionadores con y sin la sugerencia.

Los solucionadores de LP basados en Simplex suelen preferir una base inicial a una sugerencia de solución (de lo contrario, necesitan combinar la sugerencia para convertirla en una solución básica factible).

Representación JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "dualValues": {
    object (SparseDoubleVectorProto)
  }
}
Campos
variableValues

object (SparseDoubleVectorProto)

Es una asignación posiblemente parcial de valores a las variables primarias del problema. Los requisitos independientes del solucionador para este submensaje son los siguientes: * variablesValues.ids son elementos de VariablesProto.ids. * Todas las variables variablesValues.values deben ser finitas.
dualValues

object (SparseDoubleVectorProto)

Es una asignación (potencialmente parcial) de valores a las restricciones lineales del problema.

Requisitos: * dualValues.ids son elementos de LinearConstraintsProto.ids. * dobleValues.values debe ser finito.

SparseInt32VectorProto

Representación dispersa de un vector de números enteros.

Representación JSON 
{
  "ids": [
    string
  ],
  "values": [
    integer
  ]
}
Campos
ids[]

string (int64 format)

Debe ordenarse (en orden ascendente) con todos los elementos distintos.
values[]

integer

Debe tener la misma longitud que los ID.

SolveResultProto

El contrato de cuando las soluciones o los rayos primarios/duales son complejos, consulta endpoints_reasons.md para obtener una descripción completa.

Hasta que se concrete un contrato exacto, es más seguro comprobar si hay una solución o un rayo presente en lugar de depender del motivo de la rescisión.

Representación JSON 
{
  "termination": {
    object (TerminationProto)
  },
  "solutions": [
    {
      object (SolutionProto)
    }
  ],
  "primalRays": [
    {
      object (PrimalRayProto)
    }
  ],
  "dualRays": [
    {
      object (DualRayProto)
    }
  ],
  "solveStats": {
    object (SolveStatsProto)
  }
}
Campos
termination

object (TerminationProto)

Es el motivo por el que se detuvo la resolución.
solutions[]

object (SolutionProto)

El contrato general para el orden de las soluciones que los solucionadores futuros deben implementar es ordenar según lo siguiente: 1. Son las soluciones con una solución principal factible, ordenadas primero según el mejor objetivo principal. 2. Las soluciones con una solución doble factible, ordenadas por mejor objetivo doble (el objetivo doble desconocido es el peor) 3. Todas las soluciones restantes se pueden devolver en cualquier orden.
primalRays[]

object (PrimalRayProto)

Instrucciones de mejora primaria no delimitada o, de manera equivalente, certificados de inviabilidad doble. Por lo general, se proporcionan para FinishedReasonProtos UNBOUNDED y DUAL_INFEASIBLE.
dualRays[]

object (DualRayProto)

Instrucciones de mejora dual no delimitada o, de manera equivalente, certificados de inviabilidad primarias. Por lo general, se proporciona como FinishedReasonProto INFEASIBLE.
solveStats

object (SolveStatsProto)

Estadísticas sobre el proceso de resolución, p.ej., tiempo de ejecución, iteraciones.

TerminationProto

Toda la información relacionada con el motivo por el que finalizó una llamada a Resolver().

Representación JSON 
{
  "reason": enum (TerminationReasonProto),
  "limit": enum (LimitProto),
  "detail": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "objectiveBounds": {
    object (ObjectiveBoundsProto)
  }
}
Campos
reason

enum (TerminationReasonProto)

Información adicional en limit cuando el valor es TERMINATION_REASON_FEASIBLE o TERMINATION_REASON_NO_SOLUTION_FOUND. Consulta limit para obtener más información.
limit

enum (LimitProto)

Es LIMIT_UNSPECIFIED, a menos que el motivo sea TERMINATION_REASON_FEASIBLE o TERMINATION_REASON_NO_SOLUTION_FOUND. No todos los solucionadores siempre pueden determinar el límite que causó la finalización. Se usa LIMIT_UNDETERMINED cuando no se puede determinar la causa.
detail

string

Información adicional específica del solucionador de problemas relacionados con el cierre.
problemStatus

object (ProblemStatusProto)

Estados de viabilidad para problemas principales y dobles. A partir del 18 de julio de 2023, es posible que falte este mensaje. Si falta, se puede encontrar problemStatus en SolveResultProto.solve_stats.
objectiveBounds

object (ObjectiveBoundsProto)

Límites en el valor objetivo óptimo. A partir del 18 de julio de 2023, es posible que falte este mensaje. Si falta, se puede encontrar objectBounds.primal_bound en SolveResultProto.solve.stats.best_primal_bound y en SolveResultProto.solve.stats.best_dual_bound.

TerminationReasonProto

Motivo por el que finaliza una llamada a Resolver().

Enumeraciones
TERMINATION_REASON_UNSPECIFIED
TERMINATION_REASON_OPTIMAL Se encontró una solución demostrablemente óptima (hasta tolerancias numéricas).
TERMINATION_REASON_INFEASIBLE El problema principal no tiene soluciones viables.
TERMINATION_REASON_UNBOUNDED El problema principal es factible y, de manera arbitraria, se pueden encontrar buenas soluciones junto a un rayo primario.
TERMINATION_REASON_INFEASIBLE_OR_UNBOUNDED El problema principal es inviable o ilimitado. Puedes encontrar más detalles sobre el estado del problema en solveStats.problem_status. Ten en cuenta que el estado no delimitado de Gurobi se puede mapear aquí.
TERMINATION_REASON_IMPRECISE

El problema se resolvió con uno de los criterios anteriores (Optimal, Infeasible, Unbounded o InfeasibleOrUnbounded), pero no se cumplieron una o más tolerancias. Algunas soluciones o rayos primarios/dobles están presentes, pero serán un poco inviables o, si el problema era casi óptimo, podrían existir una brecha entre el objetivo de la mejor solución y el mejor objetivo de la misma forma.

Los usuarios aún pueden consultar soluciones o rayos primarios o dobles, y estadísticas de soluciones, pero son responsables de lidiar con la imprecisión numérica.
TERMINATION_REASON_FEASIBLE El optimizador alcanzó algún tipo de límite y se devuelve una solución factible principal. Consulta ResolverResultProto.limit_detail para obtener una descripción detallada del tipo de límite que se alcanzó.
TERMINATION_REASON_NO_SOLUTION_FOUND El optimizador alcanzó algún tipo de límite y no encontró una solución viable. Consulta ResolverResultProto.limit_detail para obtener una descripción detallada del tipo de límite que se alcanzó.
TERMINATION_REASON_NUMERICAL_ERROR El algoritmo se detuvo porque se produjo un error numérico irrecuperable. No hay información disponible sobre la solución.
TERMINATION_REASON_OTHER_ERROR El algoritmo se detuvo debido a un error que no está cubierto por uno de los estados definidos anteriormente. No hay información disponible sobre la solución.

LimitProto

Cuando Resolver() se detiene antes de tiempo con FinishedReasonProto FEASIBLE o NO_SOLUTION_FOUND, el límite específico que se alcanzó.

Enumeraciones
LIMIT_UNSPECIFIED Se usa como valor nulo cuando la rescisión se realiza sin un límite (p.ej., TERMINATION_REASON_OPTIMAL).
LIMIT_UNDETERMINED La herramienta de resolución subyacente no expone qué límite se alcanzó.
LIMIT_ITERATION Se detuvo un algoritmo iterativo después de realizar la cantidad máxima de iteraciones (p.ej., iteraciones simplex o de barrera).
LIMIT_TIME El algoritmo se detuvo después de un tiempo de procesamiento especificado por el usuario.
LIMIT_NODE Se detuvo un algoritmo de rama y de enlace porque exploró una cantidad máxima de nodos en el árbol de rama y límite.
LIMIT_SOLUTION El algoritmo se detuvo porque encontró la cantidad necesaria de soluciones. A menudo, se usa en MIP para que el solucionador de problemas devuelva la primera solución posible que encuentre.
LIMIT_MEMORY El algoritmo se detuvo porque se quedó sin memoria.
LIMIT_CUTOFF Se ejecutó la herramienta de resolución con un límite (p.ej., se estableció Resolver Parámetros.cutoff_limit) en el objetivo, lo que indica que el usuario no quería ninguna solución peor que el límite, y el solucionador concluyó que no había soluciones al menos tan buenas como el límite. Por lo general, no se proporciona más información sobre la solución.
LIMIT_OBJECTIVE El algoritmo se detuvo porque encontró una solución o un límite mejor que un límite establecido por el usuario (consulta ResolverParameters.objective_limit y resolveParameters.best_bound_limit).
LIMIT_NORM El algoritmo se detuvo porque la norma de una iteración se volvió demasiado grande.
LIMIT_INTERRUPTED El algoritmo se detuvo debido a una señal de interrupción o una solicitud de interrupción del usuario.
LIMIT_SLOW_PROGRESS El algoritmo se detuvo porque no pudo continuar progresando hacia la solución.
LIMIT_OTHER

El algoritmo se detuvo debido a un límite que no está cubierto por uno de los puntos anteriores. Ten en cuenta que LIMIT_UNDETERMINED se usa cuando no se puede determinar el motivo y LIMIT_OTHER se usa cuando el motivo es conocido, pero no encaja en ninguna de las alternativas anteriores.

RescisiónProto.detail puede contener información adicional sobre el límite.

ProblemStatusProto

Estado de factibilidad del problema principal y su doble (o el doble de una relajación continua) como afirma el solucionador. No es necesario que la persona que realiza la resolución devuelva un certificado para la reclamación (p.ej., la persona que resuelve el problema puede afirmar su viabilidad primaria sin devolver una solución principal viable). Este estado combinado proporciona una descripción completa de las afirmaciones de un solucionador sobre la viabilidad y la no delimitación del problema resuelto. Por ejemplo:

  • un estado factible para problemas primarios y dobles indica que el principal es factible y limitado, y es probable que tenga una solución óptima (garantizada para problemas sin restricciones no lineales).
  • un estado primordial posible y un estado doble inviable indica que el problema principal no está delimitado (es decir, tiene soluciones arbitrariamente buenas).

Ten en cuenta que un estado doble inviable por sí mismo (es decir, acompañado de un estado primario indeterminado) no implica que el problema primordial sea ilimitado, ya que podríamos hacer que ambos problemas sean inviables. Además, si bien un estado factible principal y dual puede implicar la existencia de una solución óptima, no garantiza que el solucionador haya encontrado realmente dicha solución óptima.

Representación JSON 
{
  "primalStatus": enum (FeasibilityStatusProto),
  "dualStatus": enum (FeasibilityStatusProto),
  "primalOrDualInfeasible": boolean
}
Campos
primalStatus

enum (FeasibilityStatusProto)

Estado del problema principal.
dualStatus

enum (FeasibilityStatusProto)

Estado para el problema doble (o para el doble de una relajación continua).
primalOrDualInfeasible

boolean

Si es verdadera, el solucionador afirma que el problema principal o dual es inviable, pero no sabe cuál (o si ambos son inviable). Puede ser verdadero solo cuando primal_problem_status = dual_problem_status = kIndeterminado. A menudo, esta información adicional es necesaria cuando el procesamiento previo determina que no hay una solución óptima para el problema (pero no puede determinar si se debe a una inviabilidad, a la falta de límites o a ambos).

FeasibilityStatusProto

Estado de viabilidad del problema según lo indicado por el solucionador (no es necesario que devuelva un certificado para el reclamo).

Enumeraciones
FEASIBILITY_STATUS_UNSPECIFIED Valor de Guard que indica que no hay estado.
FEASIBILITY_STATUS_UNDETERMINED La herramienta de resolución no reclama un estado.
FEASIBILITY_STATUS_FEASIBLE El solucionador afirma que el problema es factible.
FEASIBILITY_STATUS_INFEASIBLE El solucionador afirma que el problema es inviable.

ObjectiveBoundsProto

Límites en el valor objetivo óptimo.

Representación JSON 
{
  "primalBound": number,
  "dualBound": number
}
Campos
primalBound

number

El solucionador indica que el valor óptimo es igual o mejor (más pequeño para la minimización y mayor para la maximización) que primalBound hasta la tolerancia de viabilidad primaria de los solucionadores (consulta la advertencia a continuación): * primalBound es trivial (+inf para la minimización y -inf para la maximización) cuando el solucionador no afirma tener ese límite. * primalBound puede estar más cerca del valor óptimo que el objetivo de la mejor solución primaria posible. En particular, primalBound puede ser no trivial incluso cuando no se muestran soluciones posibles. Advertencia: La afirmación precisa es que existe una solución principal que: * es factible numéricamente (es decir, factible según la tolerancia de los solucionadores) y * tiene un valor objetivo primalBound. Esta solución numéricamente factible podría ser un poco inviable, en cuyo caso primalBound podría ser estrictamente mejor que el valor óptimo. Traducir una tolerancia de viabilidad primaria a una tolerancia en primalBound no es trivial, especialmente cuando la tolerancia de viabilidad es relativamente grande (p.ej., cuando se resuelve con el PDLP).
dualBound

number

El solucionador indica que el valor óptimo es igual o peor (más grande para la minimización y menor para la maximización) que DualBound hasta la tolerancia dual de viabilidad de los solucionadores (consulta la advertencia a continuación): * DualBound es trivial (inf para la minimización y +inf maximización) cuando el solucionador no afirma tener ese límite. De manera similar a primalBound, esto puede ocurrir con algunos solucionadores incluso cuando se muestra una opción óptima. Por lo general, los solucionadores del MIP informarán un límite, incluso si es impreciso. * Para problemas continuos, dualBound puede estar más cerca del valor óptimo que el objetivo de la mejor solución dual posible. Para MIP, uno de los primeros valores no triviales de DualBound es a menudo el valor óptimo de la relajación del LP del MIP. * DualBound debe ser mejor (más pequeño para la minimización y mayor para la maximización) que primalBound hasta las tolerancias de los solucionadores (consulta la advertencia a continuación). Advertencia: * Para problemas continuos, la declaración precisa es que existe una solución doble que: * es factible numéricamente (es decir, factible hasta la tolerancia de los solucionadores) y * tiene un valor objetivo dualBound. Esta solución numéricamente factible podría ser un poco inviable, en cuyo caso, DualBound podría ser estrictamente peor que el valor óptimo y primalBound. Al igual que en el caso principal, traducir una tolerancia de viabilidad doble a una tolerancia en DualBound no es trivial, en especial, cuando la tolerancia de viabilidad es relativamente grande. Sin embargo, algunos solucionadores proporcionan una versión corregida de DualBound que puede ser numéricamente más segura. Se puede acceder a esta versión corregida a través del resultado específico del solucionador de problemas (p.ej., para PDLP, pdlp_output.convergence_information.corrected_dual_objective). * Para los solucionadores de MIP, DualBound puede asociarse a una solución dual para una flexibilización continua (p.ej., relajación del LP), pero suele ser una consecuencia compleja de la ejecución de los solucionadores y, por lo general, es más impreciso que los límites informados por los solucionadores de LP.

SolutionProto

Lo que se incluye en una solución depende del tipo de problema y solucionador. Los patrones comunes actuales son 1. Los solucionadores de MIP solo muestran una solución primaria. 2. Los solucionadores de problemas de LP simplex suelen mostrar una base y las soluciones primarias y duales asociadas a ella. 3. Otros solucionadores continuos suelen mostrar soluciones primarias y duales que están conectadas en un formato que depende del solucionador.

Requisitos: * Se debe configurar al menos un campo. una solución no puede estar vacía.

Representación JSON 
{
  "primalSolution": {
    object (PrimalSolutionProto)
  },
  "dualSolution": {
    object (DualSolutionProto)
  },
  "basis": {
    object (BasisProto)
  }
}
Campos
primalSolution

object (PrimalSolutionProto)
dualSolution

object (DualSolutionProto)
basis

object (BasisProto)

PrimalSolutionProto

Es una solución a un problema de optimización.

P.ej., considera un programa lineal simple: min c * x s.t. A * x >= b x >= 0. Una solución primaria es asignar valores a x. Es factible si satisface A * x >= b y x >= 0 de arriba. En el mensaje PrimalSolutionProto a continuación, variableValues es x y goalValue es c * x.

Representación JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "objectiveValue": number,
  "auxiliaryObjectiveValues": {
    string: number,
    ...
  },
  "feasibilityStatus": enum (SolutionStatusProto)
}
Campos
variableValues

object (SparseDoubleVectorProto)

Requisitos: * variablesValues.ids son elementos de VariablesProto.ids. * Todas las variables variablesValues.values deben ser finitas.
objectiveValue

number

Valor objetivo calculado por el solucionador subyacente. No puede ser infinito o NaN.
auxiliaryObjectiveValues

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

Valores de objetivos auxiliares calculados por el solucionador subyacente. Las claves deben ser IDs de objetivos auxiliares válidos. Los valores no pueden ser infinitos o NaN.

Es un objeto que contiene una lista de pares "key": value. Ejemplo: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
feasibilityStatus

enum (SolutionStatusProto)

Estado de viabilidad de la solución según el solucionador subyacente.

DualSolutionProto

Una solución a los problemas de optimización.

P.ej., considera el par de programas lineales de par doble primario: (Primal) (Dual) mín. c * x máx. b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. La solución doble es el par (y, r). Es factible si cumple con las restricciones de (Dual) anteriores.

En el siguiente mensaje, y es dualValues, r es reduceCosts y b * y es un valor objetivo.

Representación JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  },
  "feasibilityStatus": enum (SolutionStatusProto),
  "objectiveValue": number
}
Campos
dualValues

object (SparseDoubleVectorProto)

Requisitos: * dualValues.ids son elementos de LinearConstraints.ids. * dobleValues.values debe ser finito.
reducedCosts

object (SparseDoubleVectorProto)

Requisitos: * reducidosCostos.ids son elementos de VariablesProto.ids. * Todos los reducidoscostos.valores deben ser finitos.
feasibilityStatus

enum (SolutionStatusProto)

Estado de viabilidad de la solución según el solucionador subyacente.
objectiveValue

number

PrimalRayProto

una dirección de mejora ilimitada a un problema de optimización; lo que equivale a un certificado de inviabilidad para el doble del problema de optimización.

P.ej., considera un programa lineal simple: min c * x s.t. A * x >= b x >= 0 Un rayo primario es una x que satisface: c * x < 0 A * x >= 0 x >= 0 Observa que, dada una solución factible, cualquier múltiplo positivo del rayo primario más esa solución, sigue siendo factible y proporciona un mejor valor objetivo. Un rayo primario también demuestra que el problema de la optimización dual es inviable.

En el mensaje PrimalRay a continuación, variableValues es x.

Representación JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  }
}
Campos
variableValues

object (SparseDoubleVectorProto)

Requisitos: * variablesValues.ids son elementos de VariablesProto.ids. * Todas las variables variablesValues.values deben ser finitas.

DualRayProto

Una dirección de mejora ilimitada a la doble de un problema de optimización; lo que equivale a un certificado de inviabilidad primaria.

P.ej., considera el par de programas lineales de par doble primario: (Primal) (Dual) mín. c * x máx. b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. El rayo dual es el par (y, r) que satisface: b * y > 0 y * A + r = 0 y, r >= 0 Observa que sumar un múltiplo positivo de (y, r) a la solución doble factible mantiene la viabilidad doble y mejora el objetivo (lo que demuestra que el doble no está delimitado). El rayo dual también demuestra que el problema principal es inviable.

En el mensaje DualRay a continuación, y es dualValues y r es reduceCosts.

Representación JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  }
}
Campos
dualValues

object (SparseDoubleVectorProto)

Requisitos: * dualValues.ids son elementos de LinearConstraints.ids. * dobleValues.values debe ser finito.
reducedCosts

object (SparseDoubleVectorProto)

Requisitos: * reducidosCostos.ids son elementos de VariablesProto.ids. * Todos los reducidoscostos.valores deben ser finitos.

SolveStatsProto

Representación JSON 
{
  "solveTime": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "simplexIterations": string,
  "barrierIterations": string,
  "firstOrderIterations": string,
  "nodeCount": string
}
Campos
solveTime

string (Duration format)

Tiempo transcurrido de un reloj de pared, medido por math_opt, aproximadamente el tiempo dentro de Resolverr::Solve(). Nota: Esto no incluye el trabajo realizado en la compilación del modelo.

Una duración en segundos con hasta nueve dígitos decimales, que terminan en “s”. Ejemplo: "3.5s".
problemStatus

object (ProblemStatusProto)

Estados de viabilidad para problemas principales y dobles.
simplexIterations

string (int64 format)
barrierIterations

string (int64 format)
firstOrderIterations

string (int64 format)
nodeCount

string (int64 format)