Method: mathopt.solveMathOptModel

Résoudre le modèle d'entrée et renvoie le résultat en une seule fois. Utilisez cette option lorsque vous n'avez pas besoin de rappels, d'incrémentalité ni de suivre la progression d'une solution.

Requête HTTP

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

L'URL utilise la syntaxe de transcodage gRPC.

Corps de la requête

Le corps de la requête contient des données présentant la structure suivante :

Représentation JSON 
{
  "solverType": enum (SolverTypeProto),
  "model": {
    object (ModelProto)
  },
  "parameters": {
    object (SolveParametersProto)
  },
  "modelParameters": {
    object (ModelSolveParametersProto)
  }
}
Champs
solverType

enum (SolverTypeProto)

Facultatif. Type Solveur permettant de résoudre le problème numériquement. Notez que si une solution n'est pas compatible avec une caractéristique spécifique du modèle, la procédure d'optimisation ne fonctionnera pas.
model

object (ModelProto)

Obligatoire. Représentation mathématique du problème d'optimisation à résoudre.
parameters

object (SolveParametersProto)

Facultatif. Paramètres permettant de contrôler une seule résolution. Le paramètre enableOutput est géré spécifiquement. Pour les résolveurs qui acceptent les rappels de messages, le définir sur "true" permet au serveur d'enregistrer un rappel de message. Les messages résultants seront renvoyés dans SolveMathOptModelResponse.messages. Pour les autres résolveurs, la définition de enableOutput sur "true" entraîne une erreur.
modelParameters

object (ModelSolveParametersProto)

Facultatif. Paramètres permettant de contrôler une seule résolution, spécifiques au modèle d'entrée (consultez la section SolveParametersProto pour les paramètres indépendants du modèle).

Corps de la réponse

Réponse pour une solution unaire à distance dans MathOpt.

Si la requête aboutit, le corps de la réponse contient des données qui ont la structure suivante :

Représentation JSON 
{
  "result": {
    object (SolveResultProto)
  },
  "messages": [
    string
  ]
}
Champs
result

object (SolveResultProto)

Description du résultat de la résolution du modèle dans la requête.
messages[]

string

Si SolveParametersProto.enable_output a été utilisé, il contient les messages de journal des résolveurs qui acceptent les rappels de message.

SolverTypeProto

Solutionneurs pris en charge par MathOpt.

Enums
SOLVER_TYPE_UNSPECIFIED
SOLVER_TYPE_GSCIP

Résolution d'un résolveur (tiers) de programmes SCIP (Constraint Integer Programs).

Compatible avec les problèmes quadratiques (LP, MIP, et entiers non convexes). Aucune donnée double n'est toutefois renvoyée pour les pages de destination. Optez pour le GLOP pour les pages de destination.
SOLVER_TYPE_GUROBI

Solutionneur Gurobi (tiers).

Compatible avec les problèmes quadratiques (LP, MIP, et entiers non convexes). Il s'agit généralement de l'option la plus rapide, mais elle dispose de licences spéciales.
SOLVER_TYPE_GLOP

Solution Glop de Google

Prend en charge la bibliothèque LP avec les méthodes simplex primaires et doubles.
SOLVER_TYPE_CP_SAT

le résolveur CP-SAT de Google.

Compatible avec les problèmes où toutes les variables sont des nombres entiers et limités (ou implicites d'après presolve). Assistance expérimentale permettant de redimensionner et de discrétiser les problèmes à l'aide de variables continues
SOLVER_TYPE_PDLP

Solutionneur anti-protection contre la perte de données de Google.

Compatible avec la page de destination (LP) et les objectifs quadratiques convexes (diagonales). Utilise les méthodes du premier ordre plutôt que le simplex. Peut résoudre des problèmes très importants.
SOLVER_TYPE_GLPK

GNU Linear Programming Kit (GLPK) (tiers).

Compatible avec MIP et LP.

Sécurité des threads: GLPK utilise un stockage thread local pour les allocations de mémoire. Par conséquent, les instances de Solveur doivent être détruites sur le même thread qu'elles lors de leur création, sinon GLPK plante. Il semble possible d'appeler Solver::Solve() à partir d'un autre thread que celui utilisé pour créer le Solveur, mais cela n'est pas documenté par GLPK et doit être évité.

Lors de la résolution d'un LP avec le presolver, une solution (et les rayons non liés) n'est renvoyée que si une solution optimale a été trouvée. Sinon, rien n'est renvoyé. Pour plus d'informations, consultez la page glpk-5.0/doc/glpk.pdf page 40 disponible à l'adresse glpk-5.0.tar.gz.
SOLVER_TYPE_OSQP

Solutionneur de programme quadratique de division par l'opérateur (tiers)

Prend en charge les problèmes continus avec des contraintes linéaires et des objectifs quadratiques linéaires ou convexes. Utilise une méthode de premier ordre.
SOLVER_TYPE_ECOS

Le Solveur de conique intégré (ECOS) (tiers)

Prise en charge des problèmes LP et SOCP. Utilise des méthodes de point intérieur (barrière).
SOLVER_TYPE_SCS

Solveur de conique de division (SCS) (tiers).

Prise en charge des problèmes LP et SOCP. Utilise une méthode de premier ordre.
SOLVER_TYPE_HIGHS

Le Solveur HiGHS (tiers)

Prise en charge des problèmes LP et MIP (les QP convexes ne sont pas implémentés).
SOLVER_TYPE_SANTORINI

Implémentation de référence d'un solutionneur MIP par MathOpt.

Lenteur/non recommandé pour la production. N'est pas une solution LP (pas de double information renvoyée).

ModelProto

Problème d'optimisation. MathOpt prend en charge les éléments suivants: - Variables de décision entières et continues avec limites finies facultatives. - Objectifs linéaires et quadratiques (objectifs uniques ou multiples), qu'ils soient réduits ou maximisés. - Un certain nombre de types de contraintes, y compris: * Contraintes linéaires * Contraintes quadratiques * Contraintes de cône de deuxième ordre * Contraintes logiques > Contraintes SOS1 et SOS2 > Contraintes liées aux indicateurs

Par défaut, les contraintes sont représentées par "id-to-data" Google Maps. Cependant, nous représentons des contraintes linéaires dans une "structure de tableaux" plus efficace .

Représentation 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)
    },
    ...
  }
}
Champs
name

string
variables

object (VariablesProto)
objective

object (ObjectiveProto)

Objectif principal du modèle.
auxiliaryObjectives

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

Objectifs auxiliaires à utiliser dans les modèles multi-objectifs.

Les ID de clé de mappage doivent être compris entre [0, max(int64)). Chaque priorité, et chaque nom non vide, doit être unique et distinct de l'élément objective principal.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
linearConstraints

object (LinearConstraintsProto)
linearConstraintMatrix

object (SparseDoubleMatrixProto)

Coefficients variables des contraintes linéaires.

Si une variable impliquée dans cette contrainte est supprimée, elle est traitée comme si elle était définie sur zéro.

Conditions requises: * linearConstraintMatrix.row_ids est des éléments de linearConstraints.ids. * linearConstraintMatrix.column_ids est des éléments de variables.ids. * Les entrées de la matrice non spécifiées sont des zéros. * linearConstraintMatrix.values doit tous être finis.
quadraticConstraints

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

Contraintes quadratiques du modèle.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
secondOrderConeConstraints

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

Contraintes de cône de deuxième ordre dans le modèle.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos1Constraints

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

Les contraintes SOS1 du modèle, qui limitent au maximum une valeur expression, peuvent être différentes de zéro. Les entrées facultatives weights sont un détail d'implémentation utilisé par le résolveur pour converger plus rapidement. Plus en détail, les résolveurs peuvent (ou non) utiliser ces pondérations pour sélectionner des décisions d'embranchement qui produisent des résultats "équilibrés" nœuds enfants.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos2Constraints

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

Contraintes SOS2 du modèle, qui limitent au maximum deux entrées de expression peuvent être non nulles et doivent être adjacentes dans leur ordre. Si aucun weights n'est fourni, cet ordre correspond à leur ordre linéaire dans la liste expressions. Si des valeurs weights sont présentées, le tri est effectué par rapport à ces valeurs dans l'ordre croissant.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
indicatorConstraints

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

Contraintes d'indicateur dans le modèle, qui exigent que, si une "variable d'indicateur" binaire est définie sur 1, alors une "contrainte implicite" doit être maintenue.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.

VariablesProto

Comme indiqué ci-dessous, nous définissons "#variables" = size(VariablesProto.ids).

Représentation JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "integers": [
    boolean
  ],
  "names": [
    string
  ]
}
Champs
ids[]

string (int64 format)

La valeur ne doit pas être négative, ni augmenter strictement. Impossible d'utiliser la valeur max(int64).
lowerBounds[]

number

La longueur doit être égale à #variables et aux valeurs [-inf, inf).
upperBounds[]

number

La longueur doit être égale à #variables et aux valeurs (-inf, inf]).
integers[]

boolean

La longueur doit être égale à #variables. La valeur est "false" pour les variables continues et "true" pour les variables entières.
names[]

string

Si ce champ n'est pas défini, toutes les chaînes sont considérées comme vides. Sinon, la longueur doit être égale à #variables.

Tous les noms non vides doivent être distincts.

ObjectiveProto

Représentation JSON 
{
  "maximize": boolean,
  "offset": number,
  "linearCoefficients": {
    object (SparseDoubleVectorProto)
  },
  "quadraticCoefficients": {
    object (SparseDoubleMatrixProto)
  },
  "name": string,
  "priority": string
}
Champs
maximize

boolean

"false" correspond à réduire, "true" à "maximiser"
offset

number

Doit être fini et non NaN.
linearCoefficients

object (SparseDoubleVectorProto)

Termes ObjectiveProto linéaires dans les variables de décision.

Conditions requises: * linearCoefficients.ids est un élément de VariablesProto.ids. * VariablesProto non spécifiées correspond à zéro. * Les valeurs linearCoefficients.values doivent toutes être finies. * Les valeurs linearCoefficients.values peuvent être égales à zéro, mais cela gaspille simplement de l'espace.
quadraticCoefficients

object (SparseDoubleMatrixProto)

Termes objectifs qui sont quadratiques dans les variables de décision.

Conditions requises en plus de celles concernant les messages SparseDoubleMatrixProto: * Chaque élément de quadraticCoefficients.row_ids et chaque élément de quadraticCoefficients.column_ids doit être un élément de VariablesProto.ids. * La matrice doit être triangulaire supérieure: pour chaque i, quadraticCoefficients.row_ids[i] <= quadraticCoefficients.column_ids[i].

Remarques: * Les termes qui ne sont pas explicitement stockés ont un coefficient nul. * Les éléments des coefficients quadratiques.coefficients peuvent être nuls, mais cela gaspille simplement de l'espace.
name

string

Les messages parents peuvent être soumis à des exigences d'unicité dans ce champ. par exemple, voir ModelProto.objectives et AuxiliaryObjectivesUpdatesProto.new_objectives.
priority

string (int64 format)

Pour les problèmes à plusieurs objectifs, la priorité de cet objectif par rapport aux autres (plus la valeur est basse, mieux c'est). Cette valeur ne doit pas être négative. De plus, chaque priorité d'objectif du modèle doit être distincte au moment de la résolution. Cette condition n'est pas validée au niveau du prototype. Par conséquent, les modèles peuvent temporairement avoir des objectifs ayant la même priorité.

SparseDoubleVectorProto

Représentation creuse d'un vecteur de doubles.

Représentation JSON 
{
  "ids": [
    string
  ],
  "values": [
    number
  ]
}
Champs
ids[]

string (int64 format)

Les fichiers doivent être triés (par ordre croissant) avec des éléments distincts.
values[]

number

La longueur doit être égale à celle des identifiants. Peut ne pas contenir NaN.

SparseDoubleMatrixProto

Représentation creuse d'une matrice de doubles.

La matrice est stockée sous forme de triples d'ID de ligne, d'ID de colonne et de coefficient. Ces trois vecteurs doivent être de longueur égale. Pour tous les i, le tuple (rowIds[i], columnIds[i]) doit être distinct. Les entrées doivent être placées dans l’ordre principal de la ligne.

Représentation JSON 
{
  "rowIds": [
    string
  ],
  "columnIds": [
    string
  ],
  "coefficients": [
    number
  ]
}
Champs
rowIds[]

string (int64 format)
columnIds[]

string (int64 format)
coefficients[]

number

Peut ne pas contenir NaN.

LinearConstraintsProto

Comme indiqué ci-dessous, nous définissons les "contraintes #linéaires" = size(LinearConstraintsProto.ids).

Représentation JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "names": [
    string
  ]
}
Champs
ids[]

string (int64 format)

La valeur ne doit pas être négative, ni augmenter strictement. Impossible d'utiliser la valeur max(int64).
lowerBounds[]

number

La longueur doit être égale aux contraintes #linear, valeurs dans [-inf, inf).
upperBounds[]

number

La longueur doit être égale à #linear contraintes, valeurs dans (-inf, inf].
names[]

string

Si ce champ n'est pas défini, toutes les chaînes sont considérées comme vides. Sinon, la longueur doit être égale à la contrainte #linear.

Tous les noms non vides doivent être distincts.

QuadraticConstraintProto

Une seule contrainte quadratique de la forme: lb <= sum{linearTerms} + sum{quadraticTerms} <= ub.

Si une variable impliquée dans cette contrainte est supprimée, elle est traitée comme si elle était définie sur zéro.

Représentation JSON 
{
  "linearTerms": {
    object (SparseDoubleVectorProto)
  },
  "quadraticTerms": {
    object (SparseDoubleMatrixProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string
}
Champs
linearTerms

object (SparseDoubleVectorProto)

Termes linéaires dans les variables de décision.

En plus des exigences concernant les messages SparseDoubleVectorProto, vous devez respecter les exigences suivantes: * linearTerms.ids sont des éléments de VariablesProto.ids. * linearTerms.values doit tous être Fini et non-NaN.

Remarques: * Les identifiants de variable omis sont associés à un coefficient nul. * linearTerms.values peut être égale à zéro, mais cela gaspille simplement de l'espace.
quadraticTerms

object (SparseDoubleMatrixProto)

Termes quadratiques dans les variables de décision.

Outre les exigences relatives aux messages SparseDoubleMatrixProto, vous devez respecter les exigences suivantes: * Chaque élément de quadraticTerms.row_ids et de quadraticTerms.column_ids doit être un élément de VariablesProto.ids. * La matrice doit être triangulaire supérieure: pour chaque i, quadraticTerms.row_ids[i] <= quadraticTerms.column_ids[i].

Remarques: * Les termes qui ne sont pas explicitement stockés ont un coefficient nul. * Les éléments de quadraticTerms.coefficients peuvent être nuls, mais cela gaspille simplement de l'espace.
lowerBound

number

Doit avoir une valeur [-inf, inf) et être inférieure ou égale à upperBound.
upperBound

number

La valeur doit être comprise entre (-inf, inf], et être supérieure ou égale à lowerBound.
name

string

Les messages parents peuvent être soumis à des exigences d'unicité dans ce champ. par exemple, voir ModelProto.quadratic_constraints et QuadraticConstraintUpdatesProto.new_constraints.

SecondOrderConeConstraintProto

Une seule contrainte de cône de deuxième ordre sous la forme suivante:

||argumentsToNorm||_2 <= upperBound,

où upperBound et chaque élément de argumentsToNorm sont des expressions linéaires.

Si une variable impliquée dans cette contrainte est supprimée, elle est traitée comme si elle était définie sur zéro.

Représentation JSON 
{
  "upperBound": {
    object (LinearExpressionProto)
  },
  "argumentsToNorm": [
    {
      object (LinearExpressionProto)
    }
  ],
  "name": string
}
Champs
upperBound

object (LinearExpressionProto)
argumentsToNorm[]

object (LinearExpressionProto)
name

string

Les messages parents peuvent être soumis à des exigences d'unicité dans ce champ. (par exemple, voir ModelProto.second_order_cone_constraints et SecondOrderConeConstraintUpdatesProto.new_constraints).

LinearExpressionProto

Représentation creuse d'une expression linéaire (somme pondérée des variables, plus un décalage constant).

Représentation JSON 
{
  "ids": [
    string
  ],
  "coefficients": [
    number
  ],
  "offset": number
}
Champs
ids[]

string (int64 format)

Identifiants des variables. Les fichiers doivent être triés (par ordre croissant) avec des éléments distincts.
coefficients[]

number

La longueur doit être égale à celle des identifiants. Les valeurs doivent être finies, et non NaN.
offset

number

Doit être fini et ne peut pas être NaN.

SosConstraintProto

Données permettant de représenter une seule contrainte SOS1 ou SOS2.

Si une variable impliquée dans cette contrainte est supprimée, elle est traitée comme si elle était définie sur zéro.

Représentation JSON 
{
  "expressions": [
    {
      object (LinearExpressionProto)
    }
  ],
  "weights": [
    number
  ],
  "name": string
}
Champs
expressions[]

object (LinearExpressionProto)

Expressions sur lesquelles appliquer la contrainte SOS: * SOS1: un élément au maximum peut avoir une valeur non nulle. * SOS2: au maximum deux éléments peuvent avoir des valeurs non nulles et ils doivent être adjacents dans l'ordre répété.
weights[]

number

Ce champ est vide ou de longueur égale aux expressions. Si ce champ est vide, les pondérations par défaut sont 1, 2, ... Si elles sont présentes, les entrées doivent être uniques.
name

string

Les messages parents peuvent être soumis à des exigences d'unicité dans ce champ. par exemple, voir ModelProto.sos1_constraints et SosConstraintUpdatesProto.new_constraints.

IndicatorConstraintProto

Données permettant de représenter une contrainte d'indicateur unique au format suivant: Variable(indicatorId) = (activateOnZero ? 0 : 1) Ұ borne inférieure <= expression <= borne supérieure.

Si une variable impliquée dans cette contrainte (l'indicateur ou qui apparaît dans expression) est supprimée, elle est traitée comme si elle était définie sur zéro. En particulier, la suppression de la variable d'indicateur signifie que la contrainte d'indicateur est vide si activateOnZero est défini sur "false", et qu'elle équivaut à une contrainte linéaire si activateOnZero est défini sur "true".

Représentation JSON 
{
  "activateOnZero": boolean,
  "expression": {
    object (SparseDoubleVectorProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string,
  "indicatorId": string
}
Champs
activateOnZero

boolean

Si la valeur est "true", alors si la variable d'indicateur prend la valeur 0, la contrainte implicite doit être maintenue. Sinon, si la variable d'indicateur prend la valeur 1, la contrainte implicite doit être maintenue.
expression

object (SparseDoubleVectorProto)

Doit être une expression linéaire valide par rapport au modèle conteneur: * Toutes les conditions indiquées sur SparseDoubleVectorProto, * Tous les éléments de expression.values doivent être finis, * expression.ids est un sous-ensemble de VariablesProto.ids.
lowerBound

number

La valeur doit être comprise entre [-inf, inf); ne peut pas être NaN.
upperBound

number

Doit avoir une valeur en (-inf, inf]; ne peut pas être NaN.
name

string

Les messages parents peuvent être soumis à des exigences d'unicité dans ce champ. (par exemple, voir ModelProto.indicator_constraints et IndicatorConstraintUpdatesProto.new_constraints).
indicatorId

string (int64 format)

ID correspondant à une variable binaire, ou non défini. Si cette règle n'est pas configurée, la contrainte d'indicateur est ignorée. Si cette valeur est définie, nous exigeons ce qui suit: * VariablesProto.integers[indicatorId] = true, * VariablesProto.lower_bounds[indicatorId] >= 0, * VariablesProto.upper_bounds[indicatorId] <= 1. Ces conditions ne sont pas validées par MathOpt, mais si elles ne sont pas satisfaites, le résolveur renverra une erreur lors de la résolution.

SolveParametersProto

Paramètres permettant de contrôler une seule résolution.

Contient les deux paramètres communs à tous les résolveurs (ex. : timeLimit et les paramètres d'un résolveur spécifique, comme gscip. Si une valeur est définie à la fois dans le champ "Common" et dans le champ spécifique au résolveur, le paramètre spécifique au résolveur est utilisé.

Les paramètres communs qui sont facultatifs et non définis, ou une énumération dont la valeur n'est pas spécifiée, indiquent que la valeur par défaut du résolveur est utilisée.

Les paramètres spécifiques aux résolveurs autres que ceux utilisés sont ignorés.

Les paramètres qui dépendent du modèle (par exemple, la priorité d'embranchement est définie pour chaque variable) sont transmis dans ModelSolveParametersProto.

Représentation 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
}
Champs
timeLimit

string (Duration format)

Temps maximal qu'un résolveur doit consacrer à un problème (ou un temps infini s'il n'est pas défini).

Cette valeur n'est pas une limite stricte. Le temps de résolution peut dépasser légèrement cette valeur. Ce paramètre est toujours transmis au résolveur sous-jacent. La valeur par défaut du résolveur n'est pas utilisée.

Durée en secondes avec neuf chiffres au maximum après la virgule et se terminant par "s". Exemple : "3.5s"
enableOutput

boolean

Active l'affichage des traces d'implémentation du résolveur. L'emplacement de ces traces dépend du résolveur. Pour SCIP et Gurobi, il s'agira des flux de sortie standard. Pour Glop et CP-SAT, la valeur sera LOG(INFO).

Notez que si le résolveur prend en charge le rappel de message et que l'utilisateur enregistre un rappel pour celui-ci, cette valeur de paramètre est ignorée et aucune trace n'est imprimée.
lpAlgorithm

enum (LPAlgorithmProto)

Algorithme utilisé pour résoudre un programme linéaire. Si la valeur est LP_ALGORITHM_UNSPECIFIED, utilisez l'algorithme par défaut du résolveur.

Pour les problèmes qui ne sont pas des programmes linéaires, mais où la programmation linéaire est une sous-routine, les résolveurs peuvent utiliser cette valeur. Exemple : Les résolveurs MIP l'utilisent généralement pour la résolution LP racine uniquement (et utilisent le double simplex dans le cas contraire).
presolve

enum (EmphasisProto)

Efforcez-vous de simplifier le problème avant de démarrer l'algorithme principal, ou le niveau d'effort par défaut du résolveur s'il est EMPHASIS_UNSPECIFIED.
cuts

enum (EmphasisProto)

Efforts à obtenir un assouplissement plus fort de la page de destination (MIP uniquement) ou le niveau d'effort par défaut du résolveur s'il est EMPHASIS_UNSPECIFIED.

REMARQUE: La désactivation des coupures peut empêcher les rappels d'ajouter des coupures au niveau de MIP_NODE. Ce comportement est spécifique à un solutionneur.
heuristics

enum (EmphasisProto)

Effort à trouver des solutions réalisables au-delà de celles rencontrées dans la procédure de recherche complète (MIP uniquement) ou du niveau d'effort par défaut du résolveur s'il est EMPHASIS_UNSPECIFIED.
scaling

enum (EmphasisProto)

Efforts à redimensionner le problème pour améliorer la stabilité numérique, ou le niveau d'effort par défaut du résolveur s'il est EMPHASIS_UNSPECIFIED.
iterationLimit

string (int64 format)

Limite le nombre d'itérations de l'algorithme sous-jacent (ex. : pivots simplex). Le comportement spécifique dépend du résolveur et de l'algorithme utilisés, mais il peut souvent donner une limite de résolution déterministe (une configuration supplémentaire peut être nécessaire, par exemple un thread).

Généralement compatible avec les résolveurs LP, QP et MIP, mais pour les résolveurs MIP, consultez également nodeLimit.
nodeLimit

string (int64 format)

Limite du nombre de sous-problèmes résolus dans la recherche énumération (par exemple, branche et lié). Pour de nombreux résolveurs, cela permet de limiter déterministe le calcul (une configuration supplémentaire peut être nécessaire, par exemple un thread).

En général, pour les solutionneurs MIP, consultez la section "iterLimit".
cutoffLimit

number

Le résolveur s'arrête prématurément s'il peut prouver qu'il n'existe aucune solution primaire au moins aussi bonne que le seuil.

En cas d'arrêt anticipé, le résolveur renvoie le motif d'arrêt NO_SOLUTION_FOUND et la limite CUTOFF. Il n'est pas tenu de fournir d'informations supplémentaires sur la solution. N'a aucun effet sur la valeur renvoyée en l'absence d'arrêt prématuré.

Il est recommandé d'utiliser une tolérance si vous souhaitez que des solutions dont l'objectif est exactement égal à la valeur limite soient renvoyées.

Pour en savoir plus et voir une comparaison avec bestBoundLimit, consultez le guide de l'utilisateur.
objectiveLimit

number

Le résolveur s'arrête tôt dès qu'il trouve une solution au moins aussi satisfaisante, avec un motif d'arrêt FEASIBLE et une limite de OBJECTIVE.
bestBoundLimit

number

Le résolveur s'arrête dès qu'il prouve que la meilleure limite est au moins aussi satisfaisante, avec un motif d'arrêt FEASIBLE ou NO_SOLUTION_FOUND et une limite de OBJECTIVE.

Consultez le guide de l'utilisateur pour en savoir plus et voir une comparaison avec la valeur cutoffLimit.
solutionLimit

integer

Le résolveur s'arrête tôt après avoir trouvé autant de solutions réalisables, le motif d'arrêt étant FÉASIBLE et la limite SOLUTION limitée. Doit être supérieur à zéro s'il est défini. Elle est souvent utilisée pour faire en sorte que le résolveur s'arrête à la première solution réalisable trouvée. Notez qu'il n'existe aucune garantie concernant la valeur de l'objectif pour les solutions renvoyées.

Les résolveurs ne renvoient généralement pas plus de solutions que la limite autorisée, mais MathOpt n'applique pas cette contrainte. Voir aussi b/214041169.

Actuellement disponible pour Gurobi et SCIP, et pour CP-SAT uniquement avec la valeur 1.
threads

integer

S'il est défini, il doit être >= 1.
randomSeed

integer

Graine du générateur de nombres pseudo-aléatoires dans le solutionneur sous-jacent. Notez que tous les résolveurs utilisent des nombres pseudo-aléatoires pour sélectionner des éléments tels que la perturbation dans l'algorithme LP, les règles de départage et les corrections heuristiques. Une variation de cette valeur peut avoir un impact notable sur le comportement du résolveur.

Bien que tous les résolveurs aient un concept de graines, notez que les valeurs valides dépendent du résolveur réel. - Gurobi: [0:GRB_MAXINT] (qui à partir de Gurobi 9.0 correspond à 2x10^9). - GSCIP: [0:2147483647] (MAX_INT, kint32max ou 2^31-1) - GLOP: [0:2147483647] (identique à la précédente) Dans tous les cas, le résolveur recevra une valeur égale à: MAX(0, MIN(MAX_VALID_VALUE_FOR_SOLVER, randomSeed)).
absoluteGapTolerance

number

Tolérance d'optimisation absolue (principalement) pour les solutionneurs MIP.

Le GAP absolu correspond à la valeur absolue de la différence entre: * la valeur objective de la meilleure solution possible trouvée et * la double limite produite par la recherche. Le résolveur peut s'arrêter une fois que le GAP absolu a atteint la valeur absoluteGapTolerance (une fois défini) et renvoyer TERMINATION_REASON_OPTIMAL.

Doit être supérieur ou égal à 0, le cas échéant.

Voir aussi relativeGapTolerance.
relativeGapTolerance

number

Tolérance d'optimisation relative (principalement) pour les solutionneurs MIP.

Le GAP relatif est une version normalisée de GAP absolu (défini sur absoluteGapTolerance), où la normalisation dépend de la résolution, par exemple le GAP absolu divisé par la valeur objective de la meilleure solution possible trouvée.

Le résolveur peut s'arrêter une fois que le GAP relatif a atteint la limite relativeGapTolerance (lorsqu'il est défini), et renvoyer TERMINATION_REASON_OPTIMAL.

Doit être supérieur ou égal à 0, le cas échéant.

Voir aussi absoluteGapTolerance.
solutionPoolSize

integer

Gérez jusqu'à solutionPoolSize solutions pendant vos recherches. Le pool de solutions a généralement deux fonctions: (1) Pour les résolveurs pouvant renvoyer plusieurs solutions, cela limite le nombre de solutions renvoyées. (2) Certains résolveurs peuvent exécuter des heuristiques à l'aide de solutions du pool de solutions. Par conséquent, la modification de cette valeur peut affecter le chemin de l'algorithme. Pour forcer le résolveur à remplir le pool de solutions, par exemple : avec les n meilleures solutions, nécessite une configuration supplémentaire spécifique au solutionneur.

LPAlgorithmProto

Sélectionne un algorithme pour résoudre des programmes linéaires.

Enums
LP_ALGORITHM_UNSPECIFIED
LP_ALGORITHM_PRIMAL_SIMPLEX Méthode simplex (primaire). Elles fournissent généralement des solutions primaires et doubles, des rayons primaires/doubles sur des problèmes illimités primaires et doubles, et une base.
LP_ALGORITHM_DUAL_SIMPLEX Méthode du double simplex Elles fournissent généralement des solutions primaires et doubles, des rayons primaires/doubles sur des problèmes illimités primaires et doubles, et une base.
LP_ALGORITHM_BARRIER Méthode barrière, aussi communément appelée méthode de point intérieur (IPM). Peut généralement donner des solutions primales et doubles. Certaines implémentations peuvent également s'intéresser à des problèmes illimités/infaisables. Aucune base n'est donnée, sauf si le solutionneur sous-jacent effectue un "crossover" et se termine par simplex.
LP_ALGORITHM_FIRST_ORDER Algorithme basé sur une méthode du premier ordre. Celles-ci produisent généralement des solutions primaires et doubles, et éventuellement des certificats d'infaisabilité primaire et/ou double. Les méthodes de premier ordre offrent généralement des solutions moins précises. Les utilisateurs doivent donc veiller à définir les paramètres de qualité de la solution (par exemple, les tolérances) et à valider les solutions.

EmphasisProto

Niveau d'effort appliqué à une tâche facultative lors de la résolution (voir SolveParametersProto pour utilisation).

La mise en valeur est utilisée pour configurer une fonctionnalité de solution comme suit: * Si un outil de résolution n'est pas compatible avec cette fonctionnalité, seul UNSPECIFIED est toujours valide. Tout autre paramètre génère généralement une erreur d'argument non valide (certains résolveurs peuvent également accepter OFF). * Si le résolveur prend en charge la fonctionnalité: - Si la valeur est "UNSPECIFIED" (NON SPÉCIFIÉ), la valeur par défaut sous-jacente est utilisée. - Lorsque la fonctionnalité ne peut pas être désactivée, une erreur est renvoyée. - Si la fonctionnalité est activée par défaut, la valeur par défaut du résolveur est généralement définie sur MOYEN. - Si la caractéristique est prise en charge, les valeurs LOW, MEDIUM, HIGH et TRY HIGH ne généreront jamais d'erreur et seront mises en correspondance avec la meilleure correspondance.

Enums
EMPHASIS_UNSPECIFIED
EMPHASIS_OFF
EMPHASIS_LOW
EMPHASIS_MEDIUM
EMPHASIS_HIGH
EMPHASIS_VERY_HIGH

ModelSolveParametersProto

Représentation JSON 
{
  "variableValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "dualValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "reducedCostsFilter": {
    object (SparseVectorFilterProto)
  },
  "initialBasis": {
    object (BasisProto)
  },
  "solutionHints": [
    {
      object (SolutionHintProto)
    }
  ],
  "branchingPriorities": {
    object (SparseInt32VectorProto)
  }
}
Champs
variableValuesFilter

object (SparseVectorFilterProto)

Filtre appliqué à tous les conteneurs creux renvoyés associés par des variables dans PrimalSolutionProto et PrimalRayProto (PrimalSolutionProto.variable_values, PrimalRayProto.variable_values).

Conditions requises: * Les identifiants filterId sont des éléments de VariablesProto.ids.
dualValuesFilter

object (SparseVectorFilterProto)

Filtre appliqué à tous les conteneurs creux renvoyés liés par des contraintes linéaires dans DualSolutionProto et DualRay (DualSolutionProto.dual_values, DualRay.dual_values).

Conditions requises: * Les identifiants filtrés sont des éléments de LinearConstraints.ids.
reducedCostsFilter

object (SparseVectorFilterProto)

Filtre appliqué à tous les conteneurs creux renvoyés associés par des variables dans DualSolutionProto et DualRay (DualSolutionProto.reduced_costs, DualRay.reduced_costs).

Conditions requises: * Les identifiants filterId sont des éléments de VariablesProto.ids.
initialBasis

object (BasisProto)

Base initiale facultative pour les résolveurs LP simplex à démarrage tiède. Si cette valeur est définie, elle devrait être valide selon ValidateBasis dans validators/solution_validator.h pour le ModelSummary actuel.
solutionHints[]

object (SolutionHintProto)

Conseils de solution facultatifs. Si le solutionneur sous-jacent n'accepte qu'un seul indice, le premier est utilisé.
branchingPriorities

object (SparseInt32VectorProto)

Priorités d'embranchement facultatives. Les variables ayant les valeurs les plus élevées sont ramifiées en premier. Les variables pour lesquelles aucune priorité n'est définie obtiennent la priorité par défaut du résolveur (généralement zéro).

Conditions requises: * branchingPriorities.values doit être fini. * branchingPriorities.ids doit être des éléments de VariablesProto.ids.

SparseVectorFilterProto

Ce message permet d'interroger/de définir des parties spécifiques d'un vecteur SparseXxxxVector. Le comportement par défaut consiste à ne rien filtrer. Une utilisation courante consiste à n'interroger que certaines parties de solutions (uniquement des valeurs non nulles et/ou simplement un ensemble de valeurs de variables soigneusement sélectionné).

Représentation JSON 
{
  "skipZeroValues": boolean,
  "filterByIds": boolean,
  "filteredIds": [
    string
  ]
}
Champs
skipZeroValues

boolean

Pour SparseBoolVectorProto "zero" est false.
filterByIds

boolean

Si la valeur est "true", ne renvoie que les valeurs correspondant aux ID répertoriés dans "filterIds".
filteredIds[]

string (int64 format)

Liste des ID à utiliser lorsque filterByIds a la valeur "true". Ce champ doit être vide si filterByIds est défini sur "false". REMARQUE: Si ce champ est vide et que filterByIds a la valeur "true", vous indiquez que le résultat ne doit comporter aucune information.

BasisProto

Caractérisation combinatoire d'une solution à un programme linéaire.

La méthode simplex pour résoudre des programmes linéaires renvoie toujours une "solution réalisable de base" qui peut être décrit de manière combinatoire par une base. Une base attribue un BasisStatusProto à chaque variable et contrainte linéaire.

Exemple : Prenons une forme standard LP: min c * x s.t. A * x = b x >= 0 qui a plus de variables que de contraintes et avec un rang de ligne complet A.

Soit n le nombre de variables et m le nombre de contraintes linéaires. Une base valable pour résoudre ce problème peut être définie comme suit: * Toutes les contraintes auront un état de base FIXED (FIXED). * Choisissez m variables de sorte que les colonnes de A soient linéairement indépendantes et affectez l'état BASIC. * Affecter le statut AT_LOWER pour les n - m variables restantes.

La solution de base pour cette base est la solution unique de A * x = b, qui a toutes les variables avec l'état AT_LOWER fixes à leurs limites inférieures (toutes à zéro). La solution qui en résulte est appelée solution réalisable de base si elle satisfait également à x >= 0.

Représentation JSON 
{
  "constraintStatus": {
    object (SparseBasisStatusVector)
  },
  "variableStatus": {
    object (SparseBasisStatusVector)
  },
  "basicDualFeasibility": enum (SolutionStatusProto)
}
Champs
constraintStatus

object (SparseBasisStatusVector)

État de la base de contrainte.

Conditions requises: * constraintStatus.ids est égal à LinearConstraints.ids.
variableStatus

object (SparseBasisStatusVector)

État sur une base variable.

Conditions requises: * constraintStatus.ids est égal à VariablesProto.ids.
basicDualFeasibility

enum (SolutionStatusProto)

Il s'agit d'une fonctionnalité avancée utilisée par MathOpt pour déterminer la faisabilité de solutions de page de destination non optimales (les solutions optimales auront toujours l'état SOLUTION_STATUS_FEASIBLE).

Pour les pages de destination à un seul côté, la valeur doit être égale à l'état de faisabilité de la solution double associée. Pour les pages de destination recto verso, il peut être différent dans certains cas limites (par exemple, résolutions incomplètes avec simplex primaires).

Si vous fournissez une base de départ via ModelSolveParametersProto.initial_basis, cette valeur est ignorée. Il n'est pertinent que pour la base renvoyée par SolutionProto.basis.

SparseBasisStatusVector

Représentation creuse d'un vecteur de statuts de base.

Représentation JSON 
{
  "ids": [
    string
  ],
  "values": [
    enum (BasisStatusProto)
  ]
}
Champs
ids[]

string (int64 format)

Les fichiers doivent être triés (par ordre croissant) avec des éléments distincts.
values[]

enum (BasisStatusProto)

La longueur doit être égale à celle des identifiants.

BasisStatusProto

État d'une variable/contrainte dans une base LP.

Enums
BASIS_STATUS_UNSPECIFIED Valeur de garde représentant l'absence d'état.
BASIS_STATUS_FREE La variable/contrainte est libre (elle n'a pas de limites finies).
BASIS_STATUS_AT_LOWER_BOUND La variable/contrainte est à sa limite inférieure (qui doit être finie).
BASIS_STATUS_AT_UPPER_BOUND La variable/contrainte a atteint sa limite supérieure (qui doit être finie).
BASIS_STATUS_FIXED_VALUE La variable/contrainte a des limites inférieure et supérieure finies identiques.
BASIS_STATUS_BASIC La variable/contrainte est élémentaire.

SolutionStatusProto

Faisabilité d'une solution primale ou double telle que présentée par le résolveur.

Enums
SOLUTION_STATUS_UNSPECIFIED Valeur de garde représentant l'absence d'état.
SOLUTION_STATUS_UNDETERMINED Le Solveur ne prétend pas avoir un statut de faisabilité.
SOLUTION_STATUS_FEASIBLE Le résolveur affirme que la solution est réalisable.
SOLUTION_STATUS_INFEASIBLE Le résolveur affirme que la solution est irréalisable.

SolutionHintProto

Solution de départ suggérée pour le résolveur.

Les solutionneurs MIP ne veulent généralement que les informations primaires (variableValues), tandis que les résolveurs de type LP recherchent à la fois des informations primaires et doubles (dualValues).

De nombreux solutionneurs MIP peuvent travailler avec: (1) des solutions partielles qui ne spécifient pas toutes les variables ou (2) des solutions impossibles à faire. Dans ce cas, les résolveurs résolvent généralement une sous-MIP pour compléter/corriger l'indice.

La manière dont l'indice est utilisé par le résolveur, le cas échéant, dépend fortement du résolveur, du type de problème et de l'algorithme utilisé. Le moyen le plus fiable de s'assurer que l'indice s'applique consiste à lire les journaux des résolveurs sous-jacents avec et sans l'indice.

Les résolveurs LP basés sur des requêtes simplesx préfèrent généralement une base initiale à une suggestion de solution (dans le cas contraire, ils doivent effectuer un croisement pour convertir l'indice en une solution réalisable de base).

Représentation JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "dualValues": {
    object (SparseDoubleVectorProto)
  }
}
Champs
variableValues

object (SparseDoubleVectorProto)

Affectation partielle des valeurs aux variables primaires du problème. Pour ce sous-message, les exigences sont indépendantes du résolveur: * variableValues.ids est des éléments de VariablesProto.ids. * variableValues.values doit tous être finies.
dualValues

object (SparseDoubleVectorProto)

Attribution (potentiellement partielle) de valeurs aux contraintes linéaires du problème.

Conditions requises: * dualValues.ids est des éléments de LinearConstraintsProto.ids. * dualValues.values doivent tous être finis.

SparseInt32VectorProto

Représentation creuse d'un vecteur d'ents.

Représentation JSON 
{
  "ids": [
    string
  ],
  "values": [
    integer
  ]
}
Champs
ids[]

string (int64 format)

Doit être trié (par ordre croissant) avec tous les éléments distincts.
values[]

integer

La longueur doit être égale à celle des identifiants.

SolveResultProto

Contrat indiquant quand les solutions/rayons primaires/duales sont complexes. Pour obtenir une description complète, consultez termination_reasons.md.

Tant qu'un contrat n'est pas finalisé, il est plus sûr de simplement vérifier si une solution ou un correctif existe, plutôt que de se fier au motif de la résiliation.

Représentation JSON 
{
  "termination": {
    object (TerminationProto)
  },
  "solutions": [
    {
      object (SolutionProto)
    }
  ],
  "primalRays": [
    {
      object (PrimalRayProto)
    }
  ],
  "dualRays": [
    {
      object (DualRayProto)
    }
  ],
  "solveStats": {
    object (SolveStatsProto)
  }
}
Champs
termination

object (TerminationProto)

Raison pour laquelle le résolveur s'est arrêté.
solutions[]

object (SolutionProto)

Le contrat général concernant l'ordre des solutions que les résolveurs futurs devraient mettre en œuvre est de classer par: 1. Solutions présentant une solution primaire réalisable, classées par meilleur objectif primaire en premier. 2. Solutions avec une solution double réalisable, classées selon le meilleur double objectif (le double objectif inconnu est le pire) 3. Toutes les autres solutions peuvent être retournées dans n'importe quel ordre.
primalRays[]

object (PrimalRayProto)

Instructions d'amélioration primaire illimitée ou, de façon équivalente, certificats d'incapacité double. Généralement fourni pour terminationReasonProtos UNBOUNDED et DUAL_INFEASIBLE
dualRays[]

object (DualRayProto)

Directions de la double amélioration illimitée ou, de manière équivalente, certificats d'impossibilité primaire. Généralement fourni pour EndpointReasonProto INFEASIBLE.
solveStats

object (SolveStatsProto)

Statistiques sur le processus de résolution, par exemple le temps d’exécution, les itérations.

TerminationProto

Toutes les informations concernant la raison pour laquelle un appel à Solve() s'est arrêté.

Représentation JSON 
{
  "reason": enum (TerminationReasonProto),
  "limit": enum (LimitProto),
  "detail": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "objectiveBounds": {
    object (ObjectiveBoundsProto)
  }
}
Champs
reason

enum (TerminationReasonProto)

Des informations supplémentaires sont disponibles dans limit lorsque la valeur est TERMINATION_REASON_FEASIBLE ou TERMINATION_REASON_NO_SOLUTION_FOUND. Consultez limit pour en savoir plus.
limit

enum (LimitProto)

Est LIMIT_UNSPECIFIED, sauf si le motif est TERMINATION_REASON_FEASIBLE ou TERMINATION_REASON_NO_SOLUTION_FOUND. Tous les résolveurs ne peuvent pas toujours déterminer la limite à l'origine de l'arrêt. La valeur LIMIT_UNDETERMINED est utilisée lorsque la cause ne peut pas être déterminée.
detail

string

Informations supplémentaires sur la résiliation généralement spécifiques qui permettent de résoudre le problème.
problemStatus

object (ProblemStatusProto)

États de faisabilité pour les problèmes primaires et doubles. Il est possible que ce message ne s'affiche pas à compter du 18 juillet 2023. Si ce champ n'est pas spécifié, le champ "ProblèmeStatus" se trouve dans SolveResultProto.solve_stats.
objectiveBounds

object (ObjectiveBoundsProto)

Limites de la valeur d'objectif optimale. Il est possible que ce message ne s'affiche pas à compter du 18 juillet 2023. S'il est manquant, goalBounds.primal_bound se trouve dans SolveResultProto.solve.stats.best_primal_bound et objectifBounds.dual_bound se trouve dans SolveResultProto.solve.stats.best_dual_bound

TerminationReasonProto

Raison pour laquelle un appel à la fonction Solve() se termine.

Enums
TERMINATION_REASON_UNSPECIFIED
TERMINATION_REASON_OPTIMAL Une solution qui semble optimale (avec des tolérances numériques) a été trouvée.
TERMINATION_REASON_INFEASIBLE Le problème primaire n'a pas de solution réalisable.
TERMINATION_REASON_UNBOUNDED Le problème primaire est réalisable et des solutions arbitrairement bonnes peuvent être trouvées le long d'un rayon primaire.
TERMINATION_REASON_INFEASIBLE_OR_UNBOUNDED Le problème primaire est soit irréalisable, soit illimité. Pour en savoir plus sur l'état du problème, consultez la page résolveStats.problem_status. Notez que le statut illimité de Gurobi peut être cartographié ici.
TERMINATION_REASON_IMPRECISE

Le problème a été résolu en fonction de l'un des critères ci-dessus ("Optimal", "Infeasible", "Unlimited" ou "InfeasibleOrUnbound"), mais une ou plusieurs tolérances n'ont pas été respectées. Des solutions ou rayons primaires ou doubles sont présents, mais ils sont peu faisables ou, si le problème était presque optimal, il peut s'agir d'un écart entre l'objectif de la meilleure solution et la meilleure limite objectif.

Les utilisateurs peuvent toujours interroger les solutions/rayons primaires et doubles et les statistiques des solutions, mais ils sont responsables de l'imprécision numérique.
TERMINATION_REASON_FEASIBLE L'optimiseur a atteint une sorte de limite, et une solution primaire réalisable est renvoyée. Consultez SolveResultProto.limit_detail pour une description détaillée du type de limite atteint.
TERMINATION_REASON_NO_SOLUTION_FOUND L'optimiseur a atteint une sorte de limite et n'a pas trouvé de solution primaire réalisable. Consultez SolveResultProto.limit_detail pour une description détaillée du type de limite atteint.
TERMINATION_REASON_NUMERICAL_ERROR L'algorithme s'est arrêté, car il a rencontré une erreur numérique irrécupérable. Aucune information sur la solution n'est disponible.
TERMINATION_REASON_OTHER_ERROR L'algorithme s'est arrêté en raison d'une erreur non couverte par l'un des états définis ci-dessus. Aucune information sur la solution n'est disponible.

LimitProto

Lorsqu'une fonction Solve() s'arrête de façon prématurée avec EndpointReasonProto FEASIBLE ou NO_SOLUTION_FOUND, la limite spécifique qui a été atteinte.

Enums
LIMIT_UNSPECIFIED Utilisé comme valeur nulle lorsque la suppression n'a pas abouti à une limite (par exemple, TERMINATION_REASON_OPTIMAL).
LIMIT_UNDETERMINED Le résolveur sous-jacent n'indique pas quelle limite a été atteinte.
LIMIT_ITERATION Un algorithme itératif s'est arrêté après avoir atteint le nombre maximal d'itérations (par exemple, des itérations de type simplex ou barrière).
LIMIT_TIME L'algorithme s'est arrêté après un temps de calcul spécifié par l'utilisateur.
LIMIT_NODE Un algorithme de branchement et lié s'est arrêté, car il a exploré un nombre maximal de nœuds dans l'arborescence liée.
LIMIT_SOLUTION L'algorithme s'est arrêté, car il a trouvé le nombre de solutions requis. Cette méthode est souvent utilisée dans les MIP pour que le résolveur renvoie la première solution réalisable qu'il rencontre.
LIMIT_MEMORY L'algorithme s'est arrêté, car il était à court de mémoire.
LIMIT_CUTOFF Le résolveur a été exécuté avec une limite (par exemple, SolveParameters.cutoff_limit a été défini) sur l'objectif, ce qui indique que l'utilisateur ne voulait pas d'une solution pire que l'intervalle minimal, et le résolveur a conclu qu'il n'y avait pas de solutions au moins aussi bonnes que l'intervalle minimal. En règle générale, aucune autre information sur la solution n'est fournie.
LIMIT_OBJECTIVE L'algorithme s'est arrêté, car il a trouvé une solution ou une limite supérieure à une limite définie par l'utilisateur (voir SolveParameters.objective_limit et SolveParameters.best_bound_limit).
LIMIT_NORM L'algorithme s'est arrêté, car la norme d'une itération est devenue trop étendue.
LIMIT_INTERRUPTED L'algorithme s'est arrêté en raison d'un signal d'interruption ou d'une demande d'interruption de l'utilisateur.
LIMIT_SLOW_PROGRESS L'algorithme s'est arrêté, car il n'a pas pu continuer à progresser vers la solution.
LIMIT_OTHER

L'algorithme s'est arrêté en raison d'une limite non couverte par l'un des éléments ci-dessus. Notez que LIMIT_UNDETERMINED est utilisé lorsque le motif ne peut pas être déterminé, et LIMIT_OTHER est utilisé lorsque le motif est connu, mais qu'il ne correspond à aucune des alternatives ci-dessus.

RésiliationProto.detail peut contenir des informations supplémentaires sur cette limite.

ProblemStatusProto

État de faisabilité du problème primaire et de son double (ou du double d'un assouplissement continu) tel qu'il est revendiqué par le résolveur. Le résolveur n'est pas tenu de renvoyer un certificat pour la demande (par exemple, le résolveur peut prétendre à la faisabilité primaire sans renvoyer de solution réalisable primaire). Cet état combiné donne une description complète des affirmations d'un résolveur sur la faisabilité et l'illimité du problème résolu. Exemple :

  • Un état réalisable pour les problèmes primaires et doubles indique que le premier est faisable, limité et qu'il offre probablement une solution optimale (garantie de problèmes sans contraintes non linéaires).
  • un état primaire "réalisable" et un état "double irréalisable" indiquent que le problème primaire est illimité (c'est-à-dire qu'il a des solutions arbitrairement bonnes).

Notez qu'un état double irréalisable seul (c'est-à-dire qu'il est accompagné d'un statut primaire non déterminé) n'implique pas que le problème primaire soit illimité, car les deux problèmes pourraient être irréalisables. Par ailleurs, même si un état primaire et un état double réalisable peuvent impliquer l'existence d'une solution optimale, cela ne garantit pas que le résolveur a trouvé cette solution optimale.

Représentation JSON 
{
  "primalStatus": enum (FeasibilityStatusProto),
  "dualStatus": enum (FeasibilityStatusProto),
  "primalOrDualInfeasible": boolean
}
Champs
primalStatus

enum (FeasibilityStatusProto)

État du problème primaire.
dualStatus

enum (FeasibilityStatusProto)

État du problème de double (ou du double d'un assouplissement continu).
primalOrDualInfeasible

boolean

Si la valeur est "true", le résolveur affirme que le problème primaire ou double est irréalisable, mais il ne sait pas lequel (ou s'il est impossible des deux). Ne peut être vrai que si primal_problem_status = double_problem_status = kUndedterminé. Ces informations supplémentaires sont souvent nécessaires lorsque le prétraitement détermine qu'il n'existe pas de solution optimale au problème (mais ne peut pas déterminer si le problème est dû à une irréalisabilité, à une absence de limites ou aux deux).

FeasibilityStatusProto

État de faisabilité du problème tel qu'il a été revendiqué par le résolveur (l'outil n'est pas tenu de renvoyer un certificat pour la demande).

Enums
FEASIBILITY_STATUS_UNSPECIFIED Valeur de garde représentant l'absence d'état.
FEASIBILITY_STATUS_UNDETERMINED Le Solveur ne revendique pas de statut.
FEASIBILITY_STATUS_FEASIBLE Le résolveur affirme que le problème est réalisable.
FEASIBILITY_STATUS_INFEASIBLE Le résolveur affirme que le problème est irréalisable.

ObjectiveBoundsProto

Limites de la valeur d'objectif optimale.

Représentation JSON 
{
  "primalBound": number,
  "dualBound": number
}
Champs
primalBound

number

Le résolveur affirme que la valeur optimale est égale ou supérieure (plus petite pour la minimisation et supérieure pour la maximisation) à primalBound jusqu'à la tolérance de faisabilité primaire du résolveur (voir l'avertissement ci-dessous): * primalBound est insignifiant (+inf pour la minimisation et -inf pour la maximisation) lorsque le résolveur ne prétend pas avoir une telle limite. * primalBound peut être plus proche de la valeur optimale que l'objectif de la meilleure solution primaire possible. En particulier, primalBound peut être non trivial, même si aucune solution primaire réalisable n'est renvoyée. Avertissement: L'affirmation précise est qu'il existe une solution primaire qui: * est faisable numériquement (c'est-à-dire réalisable selon la tolérance des résolveurs) et * a une valeur objective primalBound. Cette solution numériquement réalisable peut l'être légèrement, auquel cas primalBound pourrait être strictement supérieur à la valeur optimale. Traduire une tolérance de faisabilité primaire en tolérance de primalBound n'est pas triviale, surtout lorsque la tolérance de faisabilité est relativement élevée (par exemple, lors de la résolution avec la protection contre la perte de données).
dualBound

number

Le résolveur affirme que la valeur optimale est égale ou inférieure (supérieure à la minimisation et inférieure pour la maximisation) à la valeur de double Bound (voir l'avertissement ci-dessous) (voir l'avertissement ci-dessous): * dualBound est simple (-inf pour la minimisation et +inf maximisation) lorsque le résolveur ne prétend pas avoir une telle limite. Comme pour primalBound, cela peut se produire pour certains résolveurs, même lors du renvoi de la valeur optimale. Les solutionneurs MIP signalent généralement une limite, même si elle est imprécise. * Pour les problèmes continus, la fonction dualBound peut se rapprocher de la valeur optimale par rapport à l'objectif de la meilleure solution double possible. Pour la MIP, l'une des premières valeurs non triviales de dualBound est souvent la valeur optimale de l'assouplissement de la valeur de bassin (LP) de la MIP. * dualBound devrait être préférable (plus petit pour la minimisation et plus grand pour la maximisation) que primalBound jusqu'aux tolérances des résolveurs (voir l'avertissement ci-dessous). Avertissement: * Pour les problèmes continus, l'affirmation exacte est qu'il existe une double solution qui: * est numériquement faisable (c'est-à-dire faisable dans la limite de la tolérance des solutionneurs) et * a une valeur objective doubleBound. Cette solution numériquement réalisable peut être légèrement irréalisable, auquel cas dualBound pourrait être nettement inférieure à la valeur optimale et primalBound. À l'instar du cas primaire, traduire une double tolérance de faisabilité en une tolérance de doubleBound n'est pas trivial, en particulier lorsque la tolérance de faisabilité est relativement élevée. Cependant, certains résolveurs fournissent une version corrigée de doubleBound qui peut être numériquement plus sûre. Cette version corrigée est accessible via la sortie spécifique du résolveur (par exemple, pour PDLP, pdlp_output.convergence_information.corrected_dual_objective). * Pour les solutionneurs MIP, dualBound peut être associé à une solution double pour un assouplissement continu (ex. : assouplissement LP), mais il s'agit souvent d'une conséquence complexe de l'exécution des résolveurs et est généralement plus imprécis que les limites indiquées par les résolveurs LP.

SolutionProto

Ce qui est inclus dans une solution dépend du type de problème et de solutionneur. Voici les principaux modèles courants : Les solutionneurs MIP ne renvoient qu’une solution primale. 2. Les résolveurs LP simplex renvoient souvent une base ainsi que les solutions primaire et double associées à cette base. 3. D'autres solutionneurs continus renvoient souvent une solution primaire et une solution double, connectées de manière à dépendre d'une solution.

Conditions requises: * Vous devez définir au moins un champ une solution ne peut pas être vide.

Représentation JSON 
{
  "primalSolution": {
    object (PrimalSolutionProto)
  },
  "dualSolution": {
    object (DualSolutionProto)
  },
  "basis": {
    object (BasisProto)
  }
}
Champs
primalSolution

object (PrimalSolutionProto)
dualSolution

object (DualSolutionProto)
basis

object (BasisProto)

PrimalSolutionProto

Solution à un problème d'optimisation.

Exemple : Prenons un programme linéaire simple: min c * x s.t. A * x >= b x >= 0. Une solution primaire consiste à attribuer des valeurs à x. C'est faisable si les valeurs A * x >= b et x >= 0 sont satisfaisantes. Dans le message PrimalSolutionProto ci-dessous, variableValues est x et objectiveValue est c * x.

Représentation JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "objectiveValue": number,
  "auxiliaryObjectiveValues": {
    string: number,
    ...
  },
  "feasibilityStatus": enum (SolutionStatusProto)
}
Champs
variableValues

object (SparseDoubleVectorProto)

Conditions requises: * variableValues.ids est des éléments de VariablesProto.ids. * variableValues.values doit tous être finies.
objectiveValue

number

Valeur d'objectif calculée par le résolveur sous-jacent. Ne peut pas être infini ni NaN.
auxiliaryObjectiveValues

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

Valeurs d'objectif auxiliaires calculées par le résolveur sous-jacent. Les clés doivent être des identifiants d'objectifs auxiliaires valides. Les valeurs ne peuvent pas être infinies ni NaN.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
feasibilityStatus

enum (SolutionStatusProto)

État de faisabilité de la solution en fonction du résolveur sous-jacent.

DualSolutionProto

Une solution au double d'un problème d'optimisation.

Exemple : Prenons la paire de programmes linéaire primale à double paire: (Primal) (Dual) min c * x max b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. La solution double est la paire (y, r). Elle est réalisable si les contraintes de la méthode (Dual) ci-dessus sont remplies.

Dans le message ci-dessous, y correspond à doubleValues, r est réduction des coûts et b x y est une valeur objective.

Représentation JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  },
  "feasibilityStatus": enum (SolutionStatusProto),
  "objectiveValue": number
}
Champs
dualValues

object (SparseDoubleVectorProto)

Conditions requises: * dualValues.ids est des éléments de LinearConstraints.ids. * dualValues.values doivent tous être finis.
reducedCosts

object (SparseDoubleVectorProto)

Conditions requises: * ReduceCosts.ids est des éléments de VariablesProto.ids. * ReduceCosts.values doit tous être finis.
feasibilityStatus

enum (SolutionStatusProto)

État de faisabilité de la solution en fonction du résolveur sous-jacent.
objectiveValue

number

PrimalRayProto

Direction de l'amélioration illimitée d'un problème d'optimisation ; ainsi qu'un certificat d'impossibilité de résoudre le double problème d'optimisation.

Exemple : Prenons un programme linéaire simple: min c * x s.t. A * x >= b x >= 0 Un rayon primaire est un x qui satisfait: c * x < 0 A * x >= 0 x >= 0 Notez qu'après une solution faisable, tout multiple positif du rayon primaire plus cette solution est toujours réalisable et donne une meilleure valeur objective. Un rayon primaire prouve également que le problème d'optimisation de la double optimisation n'est pas réalisable.

Dans le message PrimalRay ci-dessous, variableValues a la valeur x.

Représentation JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  }
}
Champs
variableValues

object (SparseDoubleVectorProto)

Conditions requises: * variableValues.ids est des éléments de VariablesProto.ids. * variableValues.values doit tous être finies.

DualRayProto

Direction de l'amélioration illimitée du double de l'optimisation, le problème ; un certificat d'infaisabilité primaire.

Exemple : Prenons la paire de programmes linéaire primale à double paire: (Primal) (Dual) min c * x max b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. Le double rayon est la paire (y, r) qui satisfait: b * y > 0 y * A + r = 0 y, r >= 0 Notez que l'ajout d'un multiple positif de (y, r) à la solution double réalisable maintient la double faisabilité et améliore l'objectif (preuve que le double est illimité). Le double rayon prouve également que le problème primaire est irréalisable.

Dans le message DualRay ci-dessous, y correspond à dualValues et r à ReduceCosts.

Représentation JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  }
}
Champs
dualValues

object (SparseDoubleVectorProto)

Conditions requises: * dualValues.ids est des éléments de LinearConstraints.ids. * dualValues.values doivent tous être finis.
reducedCosts

object (SparseDoubleVectorProto)

Conditions requises: * ReduceCosts.ids est des éléments de VariablesProto.ids. * ReduceCosts.values doit tous être finis.

SolveStatsProto

Représentation JSON 
{
  "solveTime": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "simplexIterations": string,
  "barrierIterations": string,
  "firstOrderIterations": string,
  "nodeCount": string
}
Champs
solveTime

string (Duration format)

Durée écoulée de l'horloge murale, mesurée par math_opt, à peu près le temps dans Solver::Solve(). Remarque: cela n'inclut pas le travail effectué pour créer le modèle.

Durée en secondes avec neuf chiffres au maximum après la virgule et se terminant par "s". Exemple : "3.5s"
problemStatus

object (ProblemStatusProto)

États de faisabilité pour les problèmes primaires et doubles.
simplexIterations

string (int64 format)
barrierIterations

string (int64 format)
firstOrderIterations

string (int64 format)
nodeCount

string (int64 format)