Method: mathopt.solveMathOptModel

Risolvi il modello di input e restituisce il risultato immediatamente. Da utilizzare quando non hai bisogno di callback, di incrementalità e di monitorare l'avanzamento di una risoluzione.

Richiesta HTTP

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

L'URL utilizza la sintassi di transcodifica gRPC.

Corpo della richiesta

Il corpo della richiesta contiene dati con la seguente struttura:

Rappresentazione JSON 
{
  "solverType": enum (SolverTypeProto),
  "model": {
    object (ModelProto)
  },
  "parameters": {
    object (SolveParametersProto)
  },
  "modelParameters": {
    object (ModelSolveParametersProto)
  }
}
Campi
solverType

enum (SolverTypeProto)

(Facoltativo) Tipo di risolutore per risolvere numericamente il problema. Tieni presente che se un risolutore non supporta una funzionalità specifica del modello, la procedura di ottimizzazione non avrà esito positivo.
model

object (ModelProto)

Obbligatorio. Una rappresentazione matematica del problema di ottimizzazione da risolvere.
parameters

object (SolveParametersProto)

(Facoltativo) Parametri per controllare una singola risoluzione. Il parametro allowOutput viene gestito in modo specifico. Per i risolutori che supportano i callback dei messaggi, se il criterio viene impostato su true, il server registra un callback dei messaggi. I messaggi risultanti verranno restituiti in SolveMathOptModelResponse.messages. Per altri risolutori, l'impostazione di allowOutput su true comporterà un errore.
modelParameters

object (ModelSolveParametersProto)

(Facoltativo) Parametri per controllare una singola risoluzione specifici del modello di input (consulta SolveParametersProto per i parametri indipendenti dal modello).

Corpo della risposta

Risposta per una risoluzione remota unaria in MathOpt.

In caso di esito positivo, il corpo della risposta contiene dati con la seguente struttura:

Rappresentazione JSON 
{
  "result": {
    object (SolveResultProto)
  },
  "messages": [
    string
  ]
}
Campi
result

object (SolveResultProto)

Descrizione dell'output della risoluzione del modello nella richiesta.
messages[]

string

Se è stato utilizzato SolveParametersProto.enable_output, questo conterrà messaggi di log per i risolutori che supportano i callback dei messaggi.

SolverTypeProto

I risolutori supportati da MathOpt.

Enum
SOLVER_TYPE_UNSPECIFIED
SOLVER_TYPE_GSCIP

Risolutore di risoluzione dei vincoli interi per i programmi (SCIP) (di terze parti).

Supporta problemi quadratici LP, MIP e numeri interi non convessi. Tuttavia, non vengono restituiti dati doppi per gli LP. Preferisco il formato GLOP per gli LP.
SOLVER_TYPE_GUROBI

Risolutore di Gurobi (terza parte).

Supporta problemi quadratici LP, MIP e numeri interi non convessi. Generalmente l'opzione più veloce, ma prevede licenze speciali.
SOLVER_TYPE_GLOP

Risolutore Glop di Google.

Supporta LP con metodi semplici e doppi.
SOLVER_TYPE_CP_SAT

Il risolutore CP-SAT di Google.

Supporta problemi in cui tutte le variabili sono intere e limitate (o che si sottintendono dopo il presolvenza). Supporto sperimentale per la scalabilità e la discretizzazione dei problemi con variabili continue.
SOLVER_TYPE_PDLP

Il risolutore PDLP di Google.

Supporta obiettivi LP e obiettivi quadratici diagonali. Utilizza metodi del primo ordine anziché simplex. Consente di risolvere problemi di grandi dimensioni.
SOLVER_TYPE_GLPK

GNU Linear Programming Kit (GLPK) (di terze parti).

Supporta MIP e LP.

Sicurezza thread: GLPK utilizza l'archiviazione locale in thread per le allocazioni della memoria. Di conseguenza, le istanze del risolutore devono essere eliminate nello stesso thread in cui vengono create, altrimenti GLPK si arresta in modo anomalo. Sembra corretto chiamare il Risolutore::Solve() da un thread diverso da quello utilizzato per creare il Risolutore, ma questa funzione non è documentata da GLPK e dovrebbe essere evitata.

Quando si risolve un LP con il presolver, una soluzione (e i raggi non legati) vengono restituite solo se è stata trovata una soluzione ottimale. Altrimenti non viene restituito nulla. Vedi glpk-5.0/doc/glpk.pdf pagina #40 disponibile da glpk-5.0.tar.gz per i dettagli.
SOLVER_TYPE_OSQP

Il risolutore (di terze parti) del programma OSQP (Operator Splitting Quadratic Program).

Supporta problemi continui con vincoli lineari e obiettivi quadratici lineari o convessi. Utilizza un metodo di primo ordine.
SOLVER_TYPE_ECOS

Embedded Conic Risolutore (ECOS) (terza parte).

Supporta i problemi LP e SOCP. Utilizza metodi basati su punti interni (barriera).
SOLVER_TYPE_SCS

The Splitting Conic Risolutore (SCS) (terza parte).

Supporta i problemi LP e SOCP. Utilizza un metodo di primo ordine.
SOLVER_TYPE_HIGHS

HiGHS Risolutore (terza parte).

Supporta i problemi LP e MIP (le QP convessi non sono implementate).
SOLVER_TYPE_SANTORINI

Implementazione di riferimento di MathOpt di un risolutore MIP.

Lenta/non consigliata per la produzione. Non è un risolutore LP (non viene restituita alcuna informazione doppia).

ModelProto

Problema di ottimizzazione. Mathopt supporta: - Variabili di decisione continue e intere con limiti finiti facoltativi. - Obiettivi lineari e quadratici (obiettivi singoli o multipli), ridotti al minimo o massimizzati. - Una serie di tipi di vincoli, tra cui: * vincoli lineari * vincoli quadratici * vincoli di cono di secondo ordine * vincoli logici > Vincoli SOS1 e SOS2 > Vincoli indicatore

Per impostazione predefinita, i vincoli sono rappresentati in "id-to-data" mappe. Tuttavia, rappresentiamo i vincoli lineari in uno "struct-of-array" più efficiente. formato.

Rappresentazione 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)
    },
    ...
  }
}
Campi
name

string
variables

object (VariablesProto)
objective

object (ObjectiveProto)

L'obiettivo principale nel modello.
auxiliaryObjectives

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

Obiettivi ausiliari da utilizzare in modelli con più obiettivi.

Gli ID chiave mappa devono essere nel formato [0, max(int64)). Ogni priorità e ogni nome non vuoto devono essere univoci e diversi dal principale objective.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
linearConstraints

object (LinearConstraintsProto)
linearConstraintMatrix

object (SparseDoubleMatrixProto)

I coefficienti variabili per i vincoli lineari.

Se una variabile coinvolta in questo vincolo viene eliminata, viene trattata come se fosse impostata su zero.

Requisiti: * linearConstraintMatrix.row_ids sono elementi di linearConstraints.ids. * linearConstraintMatrix.column_id sono elementi di variables.id. * Le voci della matrice non specificate sono pari a zero. * linearConstraintMatrix.values devono essere tutti finiti.
quadraticConstraints

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

Vincoli quadratici nel modello.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
secondOrderConeConstraints

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

Vincoli del cono di secondo ordine nel modello.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos1Constraints

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

Vincoli SOS1 nel modello, che prevedono che al massimo un expression possa essere diverso da zero. Le voci facoltative weights sono un dettaglio di implementazione utilizzato dal risolutore per convergere (si spera) più rapidamente. Più in dettaglio, i risolutori possono (o non possono) utilizzare questi pesi per selezionare decisioni di diramazione che producono un effetto "bilanciato" nodi figlio.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
sos2Constraints

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

Vincoli SOS2 nel modello, che prevedono che al massimo due voci di expression possano essere diverse da zero e che devono essere adiacenti nell'ordine. Se non viene fornito alcun elemento weights, si tratta del suo ordinamento lineare nell'elenco expressions. se vengono presentati weights, l'ordinamento viene considerato in ordine crescente rispetto a questi valori.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
indicatorConstraints

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

Se una "variabile indicatore" binaria sono vincolanti, gli indicatori sono vincolanti nel modello, che lo obbligano è impostato su uno, quindi un "vincolo implicito" devono mantenere.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

VariablesProto

Come utilizzato di seguito, definiamo "#variables" = size(VariablesProto.ids).

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "integers": [
    boolean
  ],
  "names": [
    string
  ]
}
Campi
ids[]

string (int64 format)

Deve essere un numero non negativo ed essere rigorosamente in aumento. Impossibile utilizzare il valore max(int64).
lowerBounds[]

number

Devono avere una lunghezza uguale a #variable e i valori in [-inf, inf).
upperBounds[]

number

La lunghezza deve essere uguale a #variables e i valori in (-inf, inf].
integers[]

boolean

La lunghezza deve essere uguale a #variable. Il valore è falso per le variabili continue e vero per le variabili intere.
names[]

string

Se non viene impostato, si presume che siano tutte stringhe vuote. In caso contrario, deve avere la lunghezza uguale a #variables.

Tutti i nomi non vuoti devono essere distinti.

ObjectiveProto

Rappresentazione JSON 
{
  "maximize": boolean,
  "offset": number,
  "linearCoefficients": {
    object (SparseDoubleVectorProto)
  },
  "quadraticCoefficients": {
    object (SparseDoubleMatrixProto)
  },
  "name": string,
  "priority": string
}
Campi
maximize

boolean

falso è minimizzare, vero è massimizzare
offset

number

Deve essere limitato e non NaN.
linearCoefficients

object (SparseDoubleVectorProto)

Termini di ObjectiveProto lineari nelle variabili decisionali.

Requisiti: * linearCoefficients.ids è elementi di variablesProto.ids. * VariabiliProto non specificato corrisponde a zero. * linearCoefficients.values deve essere tutti finito. * linearCoefficients.values può essere zero, ma in questo modo si spreca spazio.
quadraticCoefficients

object (SparseDoubleMatrixProto)

Termini obiettivi che sono quadratici nelle variabili decisionali.

Requisiti oltre a quelli relativi ai messaggi SparseDoubleMatrixProto: * Ogni elemento di quadraticCoefficients.row_id e ogni elemento di quadraticCoefficients.column_id deve essere un elemento di variablescCoefficients.ids. * La matrice deve essere di forma triangolare superiore: per ogni i, quadraticCoefficients.row_ids[i] <= quadraticCoefficients.column_id[i].

Note: * I termini non memorizzati esplicitamente hanno un coefficiente pari a zero. * Gli elementi di quadraticCoefficients.coefficients possono essere zero, ma questo fa solo sprecare spazio.
name

string

I messaggi principali potrebbero avere requisiti di univocità in questo campo. Ad esempio, vedi ModelProto.objectives e AuxiliaryObjectivesUpdatesProto.new_objectives.
priority

string (int64 format)

Per problemi con più obiettivi, la priorità di questo obiettivo rispetto agli altri (il valore più basso è più importante). Questo valore non deve essere negativo. Inoltre, ogni priorità obiettivo nel modello deve essere distinta al momento della risoluzione. Questa condizione non è convalidata a livello di protocollo, quindi i modelli potrebbero avere temporaneamente obiettivi con la stessa priorità.

SparseDoubleVectorProto

Una rappresentazione sparsa di un vettore di doppi.

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "values": [
    number
  ]
}
Campi
ids[]

string (int64 format)

Deve essere ordinata (in ordine crescente) con tutti gli elementi distinti.
values[]

number

Deve avere la stessa lunghezza degli ID. Non può contenere NaN.

SparseDoubleMatrixProto

Una rappresentazione sparsa di una matrice di doppi.

La matrice è memorizzata come triple di ID riga, ID colonna e coefficiente. Questi tre vettori devono avere la stessa lunghezza. Per tutti i valori i, la tupla (rowIds[i], columnIds[i]) deve essere distinta. Le voci devono essere nell'ordine principale della riga.

Rappresentazione JSON 
{
  "rowIds": [
    string
  ],
  "columnIds": [
    string
  ],
  "coefficients": [
    number
  ]
}
Campi
rowIds[]

string (int64 format)
columnIds[]

string (int64 format)
coefficients[]

number

Non può contenere NaN.

LinearConstraintsProto

Come utilizzato di seguito, definiamo "#limiti lineari" = size(LinearConstraintsProto.ids).

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "lowerBounds": [
    number
  ],
  "upperBounds": [
    number
  ],
  "names": [
    string
  ]
}
Campi
ids[]

string (int64 format)

Deve essere un numero non negativo ed essere rigorosamente in aumento. Impossibile utilizzare il valore max(int64).
lowerBounds[]

number

Devono avere una lunghezza uguale a vincoli #linear e i valori devono essere in [-inf, inf).
upperBounds[]

number

La lunghezza deve essere uguale a #linear vincoli, i valori in (-inf, inf].
names[]

string

Se non viene impostato, si presume che siano tutte stringhe vuote. In caso contrario, la lunghezza deve essere uguale ai vincoli #linear.

Tutti i nomi non vuoti devono essere distinti.

QuadraticConstraintProto

Un singolo vincolo quadratico nella forma: lb <= sum{linearTerms} + somma{quadraticTerms} <= ub.

Se una variabile coinvolta in questo vincolo viene eliminata, viene trattata come se fosse impostata su zero.

Rappresentazione JSON 
{
  "linearTerms": {
    object (SparseDoubleVectorProto)
  },
  "quadraticTerms": {
    object (SparseDoubleMatrixProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string
}
Campi
linearTerms

object (SparseDoubleVectorProto)

Termini lineari nelle variabili decisionali.

Oltre ai requisiti dei messaggi SparseDoubleVectorProto, richiediamo che: * linearTerms.ids sia elementi di variablesProto.ids. * linearTerms.values deve essere tutti finito e non NaN.

Note: * Gli ID variabili omessi hanno un coefficiente corrispondente pari a zero. * linearTerms.values può essere zero, ma in questo modo spreca spazio.
quadraticTerms

object (SparseDoubleMatrixProto)

Termini quadratici nelle variabili decisionali.

Oltre ai requisiti relativi ai messaggi SparseDoubleMatrixProto, richiediamo che: * Ogni elemento di quadraticTerms.row_id e ogni elemento di quadraticTerms.column_id deve essere un elemento di variablesProto.ids. * La matrice deve essere di forma triangolare superiore: per ogni i, quadraticTerms.row_id[i] <= quadraticTerms.column_id[i].

Note: * I termini non memorizzati esplicitamente hanno un coefficiente pari a zero. * Gli elementi di quadraticTerms.coefficienti possono essere zero, ma questo fa solo sprecare spazio.
lowerBound

number

Deve avere un valore in [-inf, inf) ed essere minore o uguale a upperBound.
upperBound

number

Deve avere un valore in (-inf, inf] e essere maggiore o uguale a lowerBound.
name

string

I messaggi principali potrebbero avere requisiti di univocità in questo campo. Ad esempio, vedi ModelProto.quadratic_constraints e QuadraticConstraintUpdatesProto.new_constraints.

SecondOrderConeConstraintProto

Un singolo vincolo di secondo ordine della forma:

||argumentsToNorm||_2 <= upperBound,

dove upperBound e ogni elemento di argumentsToNorm sono espressioni lineari.

Se una variabile coinvolta in questo vincolo viene eliminata, viene trattata come se fosse impostata su zero.

Rappresentazione JSON 
{
  "upperBound": {
    object (LinearExpressionProto)
  },
  "argumentsToNorm": [
    {
      object (LinearExpressionProto)
    }
  ],
  "name": string
}
Campi
upperBound

object (LinearExpressionProto)
argumentsToNorm[]

object (LinearExpressionProto)
name

string

I messaggi principali potrebbero avere requisiti di univocità in questo campo. ad esempio, vedi ModelProto.second_order_cone_constraints e SecondOrderConeConstraintUpdatesProto.new_constraints.

LinearExpressionProto

Una rappresentazione sparsa di un'espressione lineare (una somma ponderata di variabili, più un offset costante).

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "coefficients": [
    number
  ],
  "offset": number
}
Campi
ids[]

string (int64 format)

ID delle variabili. Deve essere ordinata (in ordine crescente) con tutti gli elementi distinti.
coefficients[]

number

Deve avere la stessa lunghezza degli ID. I valori devono essere finiti non possono essere NaN.
offset

number

Deve essere limitato e non può essere NaN.

SosConstraintProto

Dati per la rappresentazione di un singolo vincolo SOS1 o SOS2.

Se una variabile coinvolta in questo vincolo viene eliminata, viene trattata come se fosse impostata su zero.

Rappresentazione JSON 
{
  "expressions": [
    {
      object (LinearExpressionProto)
    }
  ],
  "weights": [
    number
  ],
  "name": string
}
Campi
expressions[]

object (LinearExpressionProto)

Le espressioni su cui applicare il vincolo SOS: * SOS1: al massimo un elemento assume un valore diverso da zero. * SOS2: al massimo due elementi hanno valori diversi da zero e devono essere adiacenti nell'ordine ripetuto.
weights[]

number

Deve essere vuoto o della stessa lunghezza delle espressioni. Se vuoto, i pesi predefiniti sono 1, 2, ... Se presenti, le voci devono essere univoche.
name

string

I messaggi principali potrebbero avere requisiti di univocità in questo campo. Ad esempio, vedi ModelProto.sos1_constraints e SosConstraintUpdatesProto.new_constraints.

IndicatorConstraintProto

Dati per la rappresentazione di un singolo vincolo di indicatore nel formato: Variable(indicatorId) = (activateOnZero ? 0 : 1) ></bound inferiore <= espressione <= valore superiore.

Se una variabile coinvolta in questo vincolo (l'indicatore o visualizzata in expression) viene eliminata, viene trattata come se fosse impostata su zero. In particolare, se elimini la variabile indicatore, il vincolo dell'indicatore è vuoto se activateOnZero è falso e equivale a un vincolo lineare se activateOnZero è vero.

Rappresentazione JSON 
{
  "activateOnZero": boolean,
  "expression": {
    object (SparseDoubleVectorProto)
  },
  "lowerBound": number,
  "upperBound": number,
  "name": string,
  "indicatorId": string
}
Campi
activateOnZero

boolean

Se impostato su true, se la variabile indicatore assume il valore 0, il vincolo implicito deve essere valido. In caso contrario, se la variabile indicatore assume il valore 1, il vincolo implicito deve essere valido.
expression

object (SparseDoubleVectorProto)

Deve essere un'espressione lineare valida rispetto al modello contenitore: * Tutte le condizioni indicate su SparseDoubleVectorProto, * Tutti gli elementi di expression.values devono essere finiti, * expression.ids sono un sottoinsieme di VariablesProto.ids.
lowerBound

number

Deve avere un valore in [-inf, inf); non può essere NaN.
upperBound

number

Deve avere un valore in (-inf, inf]; non può essere NaN.
name

string

I messaggi principali potrebbero avere requisiti di univocità in questo campo. ad esempio, vedi ModelProto.indicator_constraints e IndicatorConstraintUpdatesProto.new_constraints.
indicatorId

string (int64 format)

Un ID corrispondente a una variabile binaria o non impostato. Se non viene configurato, il vincolo dell'indicatore viene ignorato. Se impostato, si richiede che: * variablesProto.integers[indicatorId] = true, * variablesProto.lower_bounds[indicatorId] >= 0, * variablesProto.upper_bounds[indicatorId] <= 1. Queste condizioni non sono convalidate da Mathopt, ma se non vengono soddisfatte, il risolutore restituisce un errore al momento della risoluzione.

SolveParametersProto

Parametri per controllare una singola risoluzione.

Contiene entrambi i parametri comuni a tutti i risolutori, ad esempio timeLimit e parametri di uno specifico risolutore, ad esempio gscip. Se viene impostato un valore sia nel campo comune sia nel campo specifico del risolutore, viene utilizzata l'impostazione specifica del risolutore.

I parametri comuni facoltativi e non impostati o un'enumerazione con valore non specificato indicano che viene utilizzato il risolutore predefinito.

I parametri specifici del risolutore per risolutori diversi da quello in uso vengono ignorati.

I parametri che dipendono dal modello (ad es. la priorità della diramazione è impostata per ogni variabile) vengono passati in ModelSolveParametersProto.

Rappresentazione 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
}
Campi
timeLimit

string (Duration format)

Tempo massimo che un risolutore dovrebbe dedicare al problema (o infinito se non impostato).

Questo valore non è un limite fisso, il tempo di risoluzione potrebbe essere leggermente superiore a questo valore. Questo parametro viene sempre passato al risolutore sottostante e non viene utilizzato quello predefinito.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
enableOutput

boolean

Consente di stampare le tracce di implementazione del risolutore. La posizione di queste tracce dipende dal risolutore. Per SCIP e Gurobi questi saranno gli stream di output standard. Per Glop e CP-SAT verrà visualizzato LOG(INFO).

Tieni presente che se il risolutore supporta il callback dei messaggi e l'utente registra un callback per quest'ultimo, questo valore di parametro viene ignorato e non viene stampata alcuna traccia.
lpAlgorithm

enum (LPAlgorithmProto)

L'algoritmo per risolvere un programma lineare. Se LP_ALGORITHM_UNSPECIFIED, utilizza l'algoritmo predefinito del risolutore.

Per problemi che non sono programmi lineari, ma in cui la programmazione lineare è una subroutine, i risolutori possono usare questo valore. Ad es. I risolutori MIP in genere lo usano solo per la risoluzione LP radice (in caso contrario usano il doppio simplex).
presolve

enum (EmphasisProto)

Impegnati a semplificare il problema prima di iniziare l'algoritmo principale o il livello di sforzo predefinito del risolutore se enza_UNSPECIFIED.
cuts

enum (EmphasisProto)

Impegnati per ottenere un maggiore relax da parte della pagina di destinazione (solo MIP) o il livello di sforzo predefinito del risolutore se SCRIPT_UNSPECIFIED.

NOTA: la disabilitazione dei tagli può impedire ai callback di aggiungerli a MIP_NODE. Questo comportamento è specifico del risolutore.
heuristics

enum (EmphasisProto)

Impegno nel trovare soluzioni fattibili oltre a quelle incontrate nella procedura di ricerca completa (solo MIP) o il livello di sforzo predefinito del risolutore se noreply_UNSPECIFIED.
scaling

enum (EmphasisProto)

Impegnato nel ridimensionamento del problema per migliorare la stabilità numerica o il livello di sforzo predefinito del risolutore se noreply_UNSPECIFIED.
iterationLimit

string (int64 format)

Limiti alle iterazioni dell'algoritmo sottostante (ad es. pivot simplex). Il comportamento specifico dipende dal risolutore e dall'algoritmo utilizzati, ma spesso può fornire un limite deterministico di risoluzione (potrebbe essere necessaria un'ulteriore configurazione, ad esempio un thread).

Generalmente supportato dai risolutori LP, QP e MIP, ma per i risolutori MIP vedi anche nodeLimit.
nodeLimit

string (int64 format)

Limite al numero di sottoproblemi risolti nella ricerca enumerativa (ad es. ramo e vincolato). Per molti risolutori questa opzione può essere utilizzata per limitare il calcolo in modo deterministico (potrebbe essere necessaria un'ulteriore configurazione, ad esempio un thread).

Di solito per i risolutori MIP, vedi anche iterationLimit.
cutoffLimit

number

Il risolutore si ferma prima se è in grado di dimostrare che non esistono soluzioni primali altrettanto buone quanto il limite massimo.

In caso di interruzione anticipata, il risolutore restituisce il motivo della risoluzione NO_SOLUTION_FOUND e con il limite CUTOFF. Inoltre, non è tenuto a fornire informazioni aggiuntive sulla soluzione. Non ha effetto sul valore restituito se non è prevista un'interruzione anticipata.

Ti consigliamo di utilizzare una tolleranza se vuoi che vengano restituite soluzioni con un obiettivo esattamente uguale al limite.

Consulta la guida dell'utente per ulteriori dettagli e per un confronto con bestBoundLimit.
objectiveLimit

number

Il risolutore si interrompe non appena trova una soluzione che sia almeno così buona, con motivo di risoluzione FATTIBILE e limite OBIETTIVO.
bestBoundLimit

number

Il risolutore si interrompe non appena dimostra che il limite migliore è almeno così buono, con motivo di risoluzione FEASIBLE o NO_SOLUTION_FOUND e limite OBJECTIVE.

Consulta la guida dell'utente per ulteriori dettagli e per un confronto con cutoffLimit.
solutionLimit

integer

Il risolutore si ferma presto dopo aver trovato tutte queste soluzioni fattibili, con il motivo della risoluzione FATTIBILE e limitando la SOLUZIONE. Deve essere maggiore di zero se impostato. Spesso si usa far fermare il risolutore alla prima soluzione fattibile trovata. Tieni presente che non esiste alcuna garanzia sul valore obiettivo per nessuna delle soluzioni restituite.

I risolutori di solito non restituiscono più soluzioni del limite consentito, ma questo non viene applicato da Mathopt, vedi anche b/214041169.

Attualmente supportato per Gurobi e SCIP e solo per CP-SAT con valore 1.
threads

integer

Se impostato, deve essere maggiore o uguale a 1.
randomSeed

integer

Seme del generatore di numeri pseudo-casuali nel risolutore sottostante. Tieni presente che tutti i risolutori usano numeri pseudo-casuali per selezionare elementi come la perturbazione nell'algoritmo LP, per le regole di tie-breaking e per le correzioni euristiche. Variare questo può avere un impatto notevole sul comportamento dei risolutori.

Sebbene tutti i risolutori abbiano un concetto di seed, tieni presente che i valori validi dipendono dal risolutore effettivo. - Gurobi: [0:GRB_MAXINT] (che a partire da Gurobi 9.0 è 2x10^9). - GSCIP: [0:2147483647] (che è MAX_INT o kint32max o 2^31-1). - GLOP: [0:2147483647] (come sopra) In tutti i casi, il risolutore riceverà un valore uguale a: MAX(0, MIN(MAX_VALID_VALUE_FOR_SOLVER, randomSeed)).
absoluteGapTolerance

number

Tolleranza di ottimalità assoluta (principalmente) per i risolutori MIP.

Il GAP assoluto è il valore assoluto della differenza tra: * il valore obiettivo della migliore soluzione fattibile trovata, * il doppio limite prodotto dalla ricerca. Il risolutore può interrompersi una volta che il GAP assoluto è al massimo tolleranza assoluta (se impostata) e restituire TERMINATION_REASON_OPTIMAL.

Deve essere >= 0 se impostato.

Vedi anche relativoGapTolerance.
relativeGapTolerance

number

Una tolleranza relativa di ottimizzazione (principalmente) per i risolutori MIP.

Il GAP relativo è una versione normalizzata del GAP assoluto (definito sulla Tolleranza Assoluta), in cui la normalizzazione è dipendente dal risolutore, ad esempio il GAP assoluto diviso per il valore obiettivo della migliore soluzione fattibile trovata.

Il risolutore può interrompersi una volta che il GAP relativo è al massimo tolleranza relativa (se impostata) e restituire TERMINATION_REASON_OPTIMAL.

Deve essere >= 0 se impostato.

Vedi anche AssoluteGapTolerance.
solutionPoolSize

integer

Gestisci al massimo solutionPoolSize soluzioni durante la ricerca. Il pool di soluzioni ha in genere due funzioni: (1) per i risolutori che possono restituire più di una soluzione, questo limita il numero di soluzioni che verranno restituite. (2) Alcuni risolutori potrebbero eseguire euristiche utilizzando soluzioni del pool di soluzioni, quindi la modifica di questo valore potrebbe influire sul percorso dell'algoritmo. Per costringere il risolutore a riempire il pool di soluzioni, ad es. le soluzioni n-migliori richiedono un'ulteriore configurazione specifica per il risolutore.

LPAlgorithmProto

Seleziona un algoritmo per risolvere i programmi lineari.

Enum
LP_ALGORITHM_UNSPECIFIED
LP_ALGORITHM_PRIMAL_SIMPLEX Il metodo simplex (principale). Tipicamente può fornire soluzioni primali e duali, raggi primali/doppio su problemi primo/doppio illimitato e una base.
LP_ALGORITHM_DUAL_SIMPLEX Il metodo Simplex doppio. Tipicamente può fornire soluzioni primali e duali, raggi primali/doppio su problemi primo/doppio illimitato e una base.
LP_ALGORITHM_BARRIER Il metodo della barriera, comunemente chiamato anche metodo dei punti interni (IPM) In genere possono fornire soluzioni sia primali che doppie. Alcune implementazioni possono anche produrre raggi su problemi illimitati/irattuabili. Non viene data una base a meno che il risolutore sottostante non esegua il "crossover" e termina con simplex.
LP_ALGORITHM_FIRST_ORDER Un algoritmo basato su un metodo del primo ordine. In genere queste producono soluzioni sia primali che doppie e potenzialmente anche certificati di inattuabilità primordiale e/o doppia. I metodi di primo ordine in genere forniscono soluzioni con una precisione minore, quindi gli utenti dovrebbero prestare attenzione a impostare i parametri di qualità della soluzione (ad es. le tolleranze) e a convalidare le soluzioni.

EmphasisProto

Livello di sforzo applicato a un'attività facoltativa durante la risoluzione (vedi SolveParametersProto per l'uso).

Viene utilizzata l'enfasi per configurare una caratteristica del risolutore come segue: * Se un risolutore non la supporta, sarà sempre valida solo UNSPECIFIED, qualsiasi altra impostazione genererà in genere un errore di argomento non valido (alcuni risolutori potrebbero accettare anche OFF). * Se il risolutore supporta la funzionalità: - Se impostata su UNSPECIFIED, viene utilizzato il valore predefinito sottostante. - Se non è possibile disattivare la funzione, viene mostrato un messaggio di errore su OFF. - Se la funzione è abilitata per impostazione predefinita, il risolutore predefinito è generalmente mappato a MEDIO. - Se la caratteristica è supportata, BASSO, MEDIO, ALTO e MOLTO ALTO non restituiranno mai un errore e verranno mappati alla corrispondenza migliore.

Enum
EMPHASIS_UNSPECIFIED
EMPHASIS_OFF
EMPHASIS_LOW
EMPHASIS_MEDIUM
EMPHASIS_HIGH
EMPHASIS_VERY_HIGH

ModelSolveParametersProto

Rappresentazione JSON 
{
  "variableValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "dualValuesFilter": {
    object (SparseVectorFilterProto)
  },
  "reducedCostsFilter": {
    object (SparseVectorFilterProto)
  },
  "initialBasis": {
    object (BasisProto)
  },
  "solutionHints": [
    {
      object (SolutionHintProto)
    }
  ],
  "branchingPriorities": {
    object (SparseInt32VectorProto)
  }
}
Campi
variableValuesFilter

object (SparseVectorFilterProto)

Filtro applicato a tutti i container sparsi restituiti con le variabili in PrimalSolutionProto e PrimalRayProto (PrimalSolutionProto.variable_values, PrimalRayProto.variable_values).

Requisiti: * I filtrateId sono elementi di variablesProto.ids.
dualValuesFilter

object (SparseVectorFilterProto)

Filtro applicato a tutti i container sparsi restituiti con vincoli lineari in DualSolutionProto e DualRay (DualSolutionProto.dual_values, DualRay.dual_values).

Requisiti: * I filtrateId sono elementi di LinearConstraints.ids.
reducedCostsFilter

object (SparseVectorFilterProto)

Filtro applicato a tutti i container sparsi restituiti in base a variabili in DualSolutionProto e DualRay (DualSolutionProto.reduced_costs, DualRay.reduced_costs).

Requisiti: * I filtrateId sono elementi di variablesProto.ids.
initialBasis

object (BasisProto)

Base iniziale facoltativa per i risolutori di LP con avvio a caldo. Se impostato, dovrebbe essere valido secondo ValidateBasis in validators/solution_validator.h per l'attuale ModelSummary.
solutionHints[]

object (SolutionHintProto)

Suggerimenti della soluzione facoltativi. Se il risolutore sottostante accetta un solo suggerimento, viene utilizzato il primo.
branchingPriorities

object (SparseInt32VectorProto)

Priorità di diramazione facoltative. Le variabili con valori più alti vengono ramificate per prime. Le variabili per cui non sono impostate priorità hanno la priorità predefinita del risolutore (di solito zero).

Requisiti: * branchingPriorities.values deve essere finito. * saltingPriorities.ids deve essere elementi di variablesProto.ids.

SparseVectorFilterProto

Questo messaggio consente di eseguire query/impostare parti specifiche di un oggetto SparseXxxxVector. Il comportamento predefinito non prevede alcun filtro. Un utilizzo comune consiste nell'eseguire query solo su parti di soluzioni (solo valori diversi da zero e/o solo un insieme di valori di variabili selezionati manualmente).

Rappresentazione JSON 
{
  "skipZeroValues": boolean,
  "filterByIds": boolean,
  "filteredIds": [
    string
  ]
}
Campi
skipZeroValues

boolean

Per SparseBoolVectorProto "zero" è false.
filterByIds

boolean

Se impostato su true, restituisce solo i valori corrispondenti agli ID elencati in restrictedIds.
filteredIds[]

string (int64 format)

L'elenco di ID da utilizzare quando filterByIds è true. Deve essere vuoto quando filterByIds è false. NOTA: se questo campo è vuoto e il valore di filterByIds è true, significa che non si desidera visualizzare alcuna informazione nei risultati.

BasisProto

Caratterizzazione combinatoria di una soluzione a un programma lineare.

Il metodo simplex per risolvere programmi lineari restituisce sempre una "soluzione di base fattibile" che può essere descritto combinatoriamente da una base. Una base assegna un BasisStatusProto a ogni variabile e vincolo lineare.

Ad es. consideriamo una LP in forma standard: min c * x s.t. A * x = b x >= 0 con più variabili dei vincoli e con ranking di riga completo A.

Sia n il numero di variabili e m il numero di vincoli lineari. Una base valida per questo problema può essere creata come segue: * Tutti i vincoli avranno stato Base CORRETTO. * Seleziona le variabili m in modo che le colonne di A siano linearmente indipendenti e assegni lo stato BASE. * Assegna lo stato AT_LOWER per le restanti variabili n - m.

La soluzione di base per questa base è l'unica soluzione di A * x = b in cui tutte le variabili con stato AT_LOWER sono fissate ai rispettivi limiti inferiori (tutti zero). La soluzione risultante viene definita soluzione di base fattibile se soddisfa anche x >= 0.

Rappresentazione JSON 
{
  "constraintStatus": {
    object (SparseBasisStatusVector)
  },
  "variableStatus": {
    object (SparseBasisStatusVector)
  },
  "basicDualFeasibility": enum (SolutionStatusProto)
}
Campi
constraintStatus

object (SparseBasisStatusVector)

Stato di base del vincolo.

Requisiti: * constraintStatus.ids è uguale a LinearConstraints.ids.
variableStatus

object (SparseBasisStatusVector)

Stato su base variabile.

Requisiti: * constraintStatus.ids è uguale a variablesProto.ids.
basicDualFeasibility

enum (SolutionStatusProto)

Si tratta di una funzionalità avanzata utilizzata da Mathopt per caratterizzare la fattibilità di soluzioni LP non ottimali (le soluzioni ottimali avranno sempre lo stato SOLUTION_STATUS_FEASIBLE).

Per le pagine di destinazione su un solo lato, questo deve essere uguale allo stato di fattibilità della soluzione doppia associata. Per gli LP a due lati, potrebbe essere diverso in alcuni casi limite (ad esempio, le soluzioni incomplete con il simplesso primario).

Se si fornisce una base iniziale tramite ModelSolveParametersProto.initial_basis, questo valore viene ignorato. È pertinente solo per la base restituita da SolutionProto.basis.

SparseBasisStatusVector

Una rappresentazione sparsa di un vettore di stati di base.

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "values": [
    enum (BasisStatusProto)
  ]
}
Campi
ids[]

string (int64 format)

Deve essere ordinata (in ordine crescente) con tutti gli elementi distinti.
values[]

enum (BasisStatusProto)

Deve avere la stessa lunghezza degli ID.

BasisStatusProto

Stato di una variabile/vincolo in una pagina di destinazione.

Enum
BASIS_STATUS_UNSPECIFIED Valore di Guard che rappresenta nessuno stato.
BASIS_STATUS_FREE La variabile/il vincolo è libero (non ha limiti finiti).
BASIS_STATUS_AT_LOWER_BOUND La variabile/il vincolo è al limite inferiore (che deve essere finito).
BASIS_STATUS_AT_UPPER_BOUND La variabile/il vincolo è al limite superiore (che deve essere finito).
BASIS_STATUS_FIXED_VALUE La variabile/il vincolo ha limiti inferiori e superiori identici.
BASIS_STATUS_BASIC La variabile/il vincolo è di base.

SolutionStatusProto

Fattibilità di una soluzione principale o doppia secondo quanto affermato dal risolutore.

Enum
SOLUTION_STATUS_UNSPECIFIED Valore di Guard che rappresenta nessuno stato.
SOLUTION_STATUS_UNDETERMINED Il risolutore non dichiara uno stato di fattibilità.
SOLUTION_STATUS_FEASIBLE Il risolutore afferma che la soluzione è fattibile.
SOLUTION_STATUS_INFEASIBLE Il risolutore afferma che la soluzione non è fattibile.

SolutionHintProto

Una soluzione di partenza suggerita per il risolutore.

I risolutori MIP di solito vogliono solo informazioni primali (variableValues), mentre i risolutori LP vogliono informazioni sia primali che doppie (dualValues).

Molti risolutori MIP possono lavorare con: (1) soluzioni parziali che non specificano tutte le variabili o (2) soluzioni non realizzabili. In questi casi, i risolutori in genere risolvono un MIP secondario per completare/correggere il suggerimento.

Il modo in cui il suggerimento viene utilizzato dal risolutore, se presente, dipende fortemente dal risolutore, dal tipo di problema e dall'algoritmo utilizzato. Il modo più affidabile per assicurarsi che il suggerimento abbia effetto è leggere i log dei risolutori sottostanti con e senza il suggerimento.

I risolutori di LP basati su Simplex in genere preferiscono una base iniziale a un hint di soluzione (in caso contrario, devono effettuare il crossover per convertire il suggerimento in una soluzione di base fattibile).

Rappresentazione JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "dualValues": {
    object (SparseDoubleVectorProto)
  }
}
Campi
variableValues

object (SparseDoubleVectorProto)

Un'assegnazione potenzialmente parziale di valori alle variabili primali del problema. I requisiti indipendenti dal risolutore per questo messaggio secondario sono: * variablesValues.ids è elementi di variablesProto.ids. * variabiliValues.values devono essere tutte finite.
dualValues

object (SparseDoubleVectorProto)

Un'assegnazione (potenzialmente parziale) di valori ai vincoli lineari del problema.

Requisiti: * dualValues.ids sono elementi di LinearConstraintsProto.ids. * dualValues.values deve essere tutti finito.

SparseInt32VectorProto

Una rappresentazione sparsa di un vettore di valori interi.

Rappresentazione JSON 
{
  "ids": [
    string
  ],
  "values": [
    integer
  ]
}
Campi
ids[]

string (int64 format)

Devono essere ordinate (in ordine crescente) con tutti gli elementi distinti.
values[]

integer

Deve avere la stessa lunghezza degli ID.

SolveResultProto

Il contratto relativo ai casi in cui le soluzioni/raggi primali/doppie è complesso. Vai su activation_reasons.md per una descrizione completa.

Fino a quando un contratto esatto non è finalizzato, è più sicuro controllare semplicemente se è presente una soluzione/raggio piuttosto che basarsi sul motivo della risoluzione.

Rappresentazione JSON 
{
  "termination": {
    object (TerminationProto)
  },
  "solutions": [
    {
      object (SolutionProto)
    }
  ],
  "primalRays": [
    {
      object (PrimalRayProto)
    }
  ],
  "dualRays": [
    {
      object (DualRayProto)
    }
  ],
  "solveStats": {
    object (SolveStatsProto)
  }
}
Campi
termination

object (TerminationProto)

Il motivo per cui il risolutore si è interrotto.
solutions[]

object (SolutionProto)

Il contratto generale relativo all'ordine delle soluzioni che i futuri risolutori dovrebbero implementare prevede l'ordine in base a: 1. Le soluzioni con una soluzione primordiale fattibile, ordinate in base al miglior obiettivo primordiale. 2. Le soluzioni con una duplice soluzione fattibile, ordinate dal miglior duplice obiettivo (il duplice obiettivo sconosciuto è peggiore) 3. Tutte le soluzioni rimanenti possono essere restituite in qualsiasi ordine.
primalRays[]

object (PrimalRayProto)

Istruzioni per il miglioramento primario illimitato o, equivalente, certificati di duplice infeasibility. In genere fornito per FinishReasonProtos UNBOUNDED e DUAL_INFEASIBLE
dualRays[]

object (DualRayProto)

Istruzioni per un duplice miglioramento illimitato o, in modo equivalente, certificati di inattuabilità primordiale. In genere fornito per Motivo della risoluzione del problema INFEASIBLE.
solveStats

object (SolveStatsProto)

Statistiche relative al processo di risoluzione, ad esempio di esecuzione e iterazioni.

TerminationProto

Tutte le informazioni sul motivo per cui una chiamata a Solve() è stata terminata.

Rappresentazione JSON 
{
  "reason": enum (TerminationReasonProto),
  "limit": enum (LimitProto),
  "detail": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "objectiveBounds": {
    object (ObjectiveBoundsProto)
  }
}
Campi
reason

enum (TerminationReasonProto)

Per ulteriori informazioni in limit se il valore è TERMINATION_REASON_FEASIBLE o TERMINATION_REASON_NO_SOLUTION_FOUND, consulta limit per i dettagli.
limit

enum (LimitProto)

È LIMIT_UNSPECIFIED a meno che il motivo non sia TERMINATION_REASON_FEASIBLE o TERMINATION_REASON_NO_SOLUTION_FOUND. Non tutti i risolutori possono sempre determinare il limite che ha causato l'interruzione. LIMIT_UNDETERMINED viene utilizzato quando non è possibile determinare la causa.
detail

string

Ulteriori informazioni specifiche per il risolutore di risoluzione relative alla risoluzione.
problemStatus

object (ProblemStatusProto)

Stati di fattibilità per problemi primali e doppi. A partire dal 18 luglio 2023, questo messaggio potrebbe non essere presente. Se mancante, problemStatus disponibile in SolveResultProto.solve_stats.
objectiveBounds

object (ObjectiveBoundsProto)

Limita il valore obiettivo ottimale. A partire dal 18 luglio 2023, questo messaggio potrebbe non essere presente. Se mancante, goalBounds.primal_bound può essere trovato in SolveResultProto.solve.stats.best_primal_bound e obiettiviBounds.dual_bound in SolveResultProto.solve.stats.best_dual_bound

TerminationReasonProto

Il motivo per cui una chiamata a Solve() termina.

Enum
TERMINATION_REASON_UNSPECIFIED
TERMINATION_REASON_OPTIMAL È stata trovata una soluzione dimostrabilmente ottimale (fino alle tolleranze numeriche).
TERMINATION_REASON_INFEASIBLE Il problema primordiale non ha soluzioni attuabili.
TERMINATION_REASON_UNBOUNDED Il problema primario è fattibile e le soluzioni arbitrariamente buone si possono trovare lungo un raggio primale.
TERMINATION_REASON_INFEASIBLE_OR_UNBOUNDED Il problema principale è impossibile o illimitato. È possibile che siano disponibili ulteriori dettagli sullo stato del problema in solveStats.problem_status. Tieni presente che lo stato illimitato di Gurobi potrebbe essere mappato qui.
TERMINATION_REASON_IMPRECISE

Il problema è stato risolto in base a uno dei criteri sopra riportati (Ottima, Non fattibile, Illimitata o InfeasibleOrUnbounded), ma una o più tolleranze non sono state soddisfatte. Esistono alcune soluzioni/raggi primali/doppie, ma saranno leggermente inattuabili oppure (se il problema era quasi ottimale) potrebbero esserci un divario tra il miglior obiettivo della soluzione e il miglior legame di obiettivo.

Gli utenti possono comunque eseguire query su soluzioni/raggi primari/doppie e statistiche delle soluzioni, ma sono responsabili dell'imprecisione numerica.
TERMINATION_REASON_FEASIBLE L'ottimizzatore ha raggiunto un qualche tipo di limite e viene restituita una soluzione primaria fattibile. Vedi SolveResultProto.limit_detail per una descrizione dettagliata del tipo di limite raggiunto.
TERMINATION_REASON_NO_SOLUTION_FOUND L'ottimizzatore ha raggiunto una sorta di limite e non ha trovato una soluzione principale fattibile. Vedi SolveResultProto.limit_detail per una descrizione dettagliata del tipo di limite raggiunto.
TERMINATION_REASON_NUMERICAL_ERROR L'algoritmo è stato interrotto perché ha riscontrato un errore numerico irreversibile. Non sono disponibili informazioni sulla soluzione.
TERMINATION_REASON_OTHER_ERROR L'algoritmo si è interrotto a causa di un errore non contemplato da uno degli stati definiti sopra. Non sono disponibili informazioni sulla soluzione.

LimitProto

Quando una Solve() si arresta in anticipo con TerminaReasonProto FEASIBLE o NO_SOLUTION_FOUND, il limite specifico raggiunto.

Enum
LIMIT_UNSPECIFIED Utilizzato come valore nullo quando abbiamo terminato l'esperimento non rientrando in un limite (ad es. TERMINATION_REASON_OPTIMAL).
LIMIT_UNDETERMINED Il risolutore sottostante non svela quale limite è stato raggiunto.
LIMIT_ITERATION Un algoritmo iterativo si è interrotto dopo aver eseguito il numero massimo di iterazioni (ad es. simplex o iterazioni di barriera).
LIMIT_TIME L'algoritmo si è interrotto dopo un tempo di calcolo specificato dall'utente.
LIMIT_NODE Un algoritmo ramo e associato si è arrestato perché ha esplorato un numero massimo di nodi nell'albero rami e legati.
LIMIT_SOLUTION L'algoritmo si è interrotto perché ha trovato il numero necessario di soluzioni. Questo viene spesso utilizzato nei MIP per fare in modo che il risolutore restituisca la prima soluzione praticabile che incontra.
LIMIT_MEMORY L'algoritmo si è interrotto perché ha esaurito la memoria.
LIMIT_CUTOFF Il risolutore è stato eseguito con un limite (ad es. è stato impostato SolveParameters.cutoff_limit) sull'obiettivo, indicando che l'utente non voleva alcuna soluzione peggiore del limite e ha concluso che non esistevano soluzioni almeno uguali al limite. In genere non vengono fornite ulteriori informazioni sulla soluzione.
LIMIT_OBJECTIVE L'algoritmo è stato interrotto perché ha trovato una soluzione o un limite migliore di un limite impostato dall'utente (vedi SolveParameters.objective_limit e SolveParameters.best_bound_limit).
LIMIT_NORM L'algoritmo si è interrotto perché la norma di un'iterazione è diventata troppo grande.
LIMIT_INTERRUPTED L'algoritmo si è interrotto a causa di un segnale di interruzione o di una richiesta di interruzione dell'utente.
LIMIT_SLOW_PROGRESS L'algoritmo si è interrotto perché non è stato in grado di continuare a progredire verso la soluzione.
LIMIT_OTHER

L'algoritmo si è interrotto a causa di un limite non coperto da uno dei precedenti. Tieni presente che LIMIT_UNDETERMINED viene utilizzato quando non è possibile determinare il motivo, mentre LIMIT_OTHER viene utilizzato quando il motivo è noto ma non rientra in nessuna delle alternative precedenti.

TerminazioneProto.detail può contenere informazioni aggiuntive sul limite.

ProblemStatusProto

Stato di fattibilità del problema primordiale e del suo duplice (o del doppio di un rilassamento continuo) come dichiarato dal risolutore. Il risolutore non è tenuto a restituire un certificato per la dichiarazione (ad esempio, può affermare la fattibilità principale senza restituire una soluzione primale fattibile). Questo stato combinato fornisce una descrizione completa delle affermazioni del risolutore circa la fattibilità e l'illimitazione del problema risolto. Ad esempio:

  • uno stato fattibile per problemi primali e doppi indica che il primole è fattibile e limitato e probabilmente ha una soluzione ottimale (garantita per problemi senza vincoli non lineari).
  • uno stato primitivo fattibile e uno stato duplice non fattibile indica che il problema primordiale è illimitato (ovvero ha soluzioni arbitrariamente buone).

Tieni presente che un duplice stato non fattibile di per sé (ovvero accompagnato da uno stato primoale indeterminato) non implica che il problema principale sia illimitato, in quanto entrambi i problemi potrebbero essere inattuabili. Inoltre, anche se uno stato primo e due di fattibili possono implicare l'esistenza di una soluzione ottimale, non garantisce che il risolutore abbia effettivamente trovato una soluzione ottimale.

Rappresentazione JSON 
{
  "primalStatus": enum (FeasibilityStatusProto),
  "dualStatus": enum (FeasibilityStatusProto),
  "primalOrDualInfeasible": boolean
}
Campi
primalStatus

enum (FeasibilityStatusProto)

Stato del problema principale.
dualStatus

enum (FeasibilityStatusProto)

Stato per il duplice problema (o per il duplice di un rilassamento continuo).
primalOrDualInfeasible

boolean

Se è vero, il risolutore afferma che il problema principale o duplice è inattuabile, ma non sa quale (o se entrambi sono inattuabili). Può essere vero solo quando primal_problem_status = dual_problem_status = kUndeterminato. Queste informazioni aggiuntive sono spesso necessarie quando la pre-elaborazione determina che non esiste una soluzione ottimale al problema (ma non è in grado di determinare se il problema è dovuto a inattuabilità, illimitatezza o entrambi).

FeasibilityStatusProto

Stato di fattibilità del problema come dichiarato dal risolutore (il risolutore non è tenuto a restituire un certificato per la dichiarazione).

Enum
FEASIBILITY_STATUS_UNSPECIFIED Valore di Guard che rappresenta nessuno stato.
FEASIBILITY_STATUS_UNDETERMINED Il risolutore non rivendica uno stato.
FEASIBILITY_STATUS_FEASIBLE Il risolutore afferma che il problema è fattibile.
FEASIBILITY_STATUS_INFEASIBLE Il risolutore afferma che il problema non è fattibile.

ObjectiveBoundsProto

Limita il valore obiettivo ottimale.

Rappresentazione JSON 
{
  "primalBound": number,
  "dualBound": number
}
Campi
primalBound

number

Il risolutore afferma che il valore ottimale è uguale o migliore (più piccolo per la minimizzazione e più grande per la massimizzazione) del primo associato fino alla tolleranza di fattibilità primordiale del risolutore (vedere l'avviso di seguito): * primalBound è banale (+inf per la minimizzazione e la massimizzazione -inf) quando il risolutore non afferma di avere tale limite. * PrimalBound può essere più vicino al valore ottimale che all'obiettivo della migliore soluzione primordiale fattibile. In particolare, primolBound potrebbe essere non banale anche se non vengono restituite soluzioni primordili attuabili. Avvertenza: l'affermazione precisa è che esiste una soluzione primale che: * è numericamente fattibile (ovvero fattibile fino alla tolleranza dei risolutori) e * ha un valore obiettivo primalBound. Questa soluzione numericamente fattibile potrebbe essere leggermente inattuabile, nel qual caso primalBound potrebbe essere strettamente migliore del valore ottimale. Tradurre una tolleranza di fattibilità primaria in una tolleranza sul vincolo primale non è banale, soprattutto quando la tolleranza di fattibilità è relativamente grande (ad esempio, quando si risolve con PDLP).
dualBound

number

Il risolutore afferma che il valore ottimale è uguale o peggiore (più grande per la minimizzazione e minore per la massimizzazione) rispetto a dualBound fino alla tolleranza di doppia fattibilità (vedi avviso di seguito): Analogamente a primalBound, questo può accadere per alcuni risolutori anche quando si restituisce un risultato ottimale. I risolutori MIP in genere riportano un limite anche se è impreciso. * per problemi continui, dualBound può essere più vicino al valore ottimale che all'obiettivo della migliore soluzione doppia fattibile. Nel caso della funzione MIP, uno dei primi valori non banali per il modello dualBound è spesso il valore ottimale del rilassamento dell'LP del MIP. * il metodo dualBound dovrebbe essere migliore (più piccolo per la minimizzazione e più grande per la massimizzazione) del vincolo principale fino alle tolleranze del risolutore (vedi l'avviso di seguito). Avviso: * per problemi continui, l'affermazione precisa è che esiste una duplice soluzione che: * è numericamente fattibile (ovvero fattibile fino alla tolleranza del risolutore) e * ha un valore obiettivo dualBound. Questa soluzione numericamente fattibile potrebbe essere leggermente inattuabile, nel qual caso dualBound potrebbe essere severamente peggiore del valore ottimale e del primolBound. Analogamente al caso principale, la traduzione di una tolleranza di duplice fattibilità in una tolleranza su dualBound non è banale, soprattutto quando la tolleranza di fattibilità è relativamente grande. Tuttavia, alcuni risolutori forniscono una versione corretta di dualBound che può essere numericamente più sicura. È possibile accedere alla versione corretta tramite l'output specifico del risolutore (ad es. per PDLP, pdlp_output.convergence_information.corred_dual_objective). * Per i risolutori MIP, dualBound può essere associato a una soluzione doppia per un certo rilassamento continuo (ad esempio il rilassamento di LP), ma spesso è una conseguenza complessa dell'esecuzione dei risolutori ed è tipicamente più imprecisa dei limiti riportati dai risolutori LP.

SolutionProto

Gli elementi inclusi in una soluzione dipendono dal tipo di problema e di risoluzione. Gli attuali pattern comuni sono 1. I risolutori MIP restituiscono solo una soluzione primordiale. 2. I risolutori di LP Simplex spesso restituiscono una base e sono associate alle soluzioni primali e duali. 3. Altri risolutori continui spesso restituiscono una soluzione primale e doppia che sono collegate in una forma dipendente dal risolutore.

Requisiti: * deve essere impostato almeno un campo; una soluzione non può essere vuota.

Rappresentazione JSON 
{
  "primalSolution": {
    object (PrimalSolutionProto)
  },
  "dualSolution": {
    object (DualSolutionProto)
  },
  "basis": {
    object (BasisProto)
  }
}
Campi
primalSolution

object (PrimalSolutionProto)
dualSolution

object (DualSolutionProto)
basis

object (BasisProto)

PrimalSolutionProto

Una soluzione a un problema di ottimizzazione.

Ad es. consideriamo un programma lineare semplice: min c * x s.t. A * x >= b x >= 0. Una soluzione principale è l'assegnazione dei valori a x. È fattibile se soddisfa A * x >= b e x >= 0 dall'alto. Nel messaggio PrimalSolutionProto riportato di seguito, variablesValues è x e objectValue è c * x.

Rappresentazione JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  },
  "objectiveValue": number,
  "auxiliaryObjectiveValues": {
    string: number,
    ...
  },
  "feasibilityStatus": enum (SolutionStatusProto)
}
Campi
variableValues

object (SparseDoubleVectorProto)

Requisiti: * variablesValues.ids è elementi di variablesProto.ids. * variabiliValues.values devono essere tutte finite.
objectiveValue

number

Valore obiettivo calcolato dal risolutore sottostante. Non può essere infinita o NaN.
auxiliaryObjectiveValues

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

Valori degli obiettivi ausiliari calcolati dal risolutore sottostante. Le chiavi devono essere ID di obiettivi ausiliari validi. I valori non possono essere infiniti o NaN.

Un oggetto contenente un elenco di "key": value coppie. Esempio: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
feasibilityStatus

enum (SolutionStatusProto)

Stato di fattibilità della soluzione in base al risolutore sottostante.

DualSolutionProto

Una soluzione al duplice problema di ottimizzazione.

Ad es. consideriamo la coppia di programmi lineari a doppia coppia primale: (Primale) (Doppia) min c * x max b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. La duplice soluzione è la coppia (y, r). È fattibile se soddisfa i vincoli specificati in (Dual) sopra.

Nel messaggio seguente, y è un valore dualValue, r è ridotto a costi e b * y è un valore obiettivo.

Rappresentazione JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  },
  "feasibilityStatus": enum (SolutionStatusProto),
  "objectiveValue": number
}
Campi
dualValues

object (SparseDoubleVectorProto)

Requisiti: * dualValues.ids sono elementi di LinearConstraints.ids. * dualValues.values deve essere tutti finito.
reducedCosts

object (SparseDoubleVectorProto)

Requisiti: * ReduceCosts.ids è elementi di variablesProto.ids. * restrictedCosts.values devono essere tutti finiti.
feasibilityStatus

enum (SolutionStatusProto)

Stato di fattibilità della soluzione in base al risolutore sottostante.
objectiveValue

number

PrimalRayProto

Una direzione di miglioramento illimitato a un problema di ottimizzazione; in modo equivalente, un certificato di inattuabilità per il duplice problema di ottimizzazione.

Ad es. consideriamo un programma lineare semplice: min c * x s.t. A * x >= b x >= 0 Un raggio primario è un x che soddisfa: c * x < 0 A * x >= 0 x >= 0 Osservare che data una soluzione fattibile, qualsiasi multiplo positivo del raggio primario più quella soluzione è ancora fattibile e fornisce un valore obiettivo migliore. Un raggio primario dimostra inoltre che il problema della doppia ottimizzazione non è fattibile.

Nel messaggio PrimalRay seguente, variablesValues è x.

Rappresentazione JSON 
{
  "variableValues": {
    object (SparseDoubleVectorProto)
  }
}
Campi
variableValues

object (SparseDoubleVectorProto)

Requisiti: * variablesValues.ids è elementi di variablesProto.ids. * variabiliValues.values devono essere tutte finite.

DualRayProto

una direzione di miglioramento illimitato al doppio di un problema di ottimizzazione; in modo equivalente, un certificato di inattuabilità primaria.

Ad es. consideriamo la coppia di programmi lineari a doppia coppia primale: (Primale) (Doppia) min c * x max b * y s.t. A * x >= b s.t. y * A + r = c x >= 0 y, r >= 0. Il doppio raggio è la coppia (y, r) che soddisfa: b * y > 0 y * A + r = 0 y, r >= 0 Si noti che l'aggiunta di un multiplo positivo di (y, r) alla duplice soluzione mantiene la duplice fattibilità e migliora l'obiettivo (dimostrando che il duplice è illimitato). Il doppio raggio dimostra anche che il problema principale è inattuabile.

Nel messaggio DualRay riportato di seguito, y è un valore dualValue e r è ridotto a costi.

Rappresentazione JSON 
{
  "dualValues": {
    object (SparseDoubleVectorProto)
  },
  "reducedCosts": {
    object (SparseDoubleVectorProto)
  }
}
Campi
dualValues

object (SparseDoubleVectorProto)

Requisiti: * dualValues.ids sono elementi di LinearConstraints.ids. * dualValues.values deve essere tutti finito.
reducedCosts

object (SparseDoubleVectorProto)

Requisiti: * ReduceCosts.ids è elementi di variablesProto.ids. * restrictedCosts.values devono essere tutti finiti.

SolveStatsProto

Rappresentazione JSON 
{
  "solveTime": string,
  "problemStatus": {
    object (ProblemStatusProto)
  },
  "simplexIterations": string,
  "barrierIterations": string,
  "firstOrderIterations": string,
  "nodeCount": string
}
Campi
solveTime

string (Duration format)

Tempo trascorso dall'orologio reale misurato da math_opt, più o meno il tempo all'interno di Solver::Solve(). Nota: non è incluso il lavoro svolto durante la creazione del modello.

Durata in secondi con un massimo di nove cifre frazionarie e termina con "s". Esempio: "3.5s".
problemStatus

object (ProblemStatusProto)

Stati di fattibilità per problemi primali e doppi.
simplexIterations

string (int64 format)
barrierIterations

string (int64 format)
firstOrderIterations

string (int64 format)
nodeCount

string (int64 format)