Method: mathopt.solveMathOptModel

Risolve il modello di input e restituisce il risultato contemporaneamente. Da utilizzare quando non hai bisogno di callback, di incrementalità e non hai bisogno 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)

Campo facoltativo. Tipo di risolutore per risolvere numericamente il problema. Tieni presente che se un risolutore non supporta una caratteristica specifica del modello, la procedura di ottimizzazione non andrà a buon fine.
model

object (ModelProto)

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

object (SolveParametersProto)

Campo facoltativo. Parametri per controllare una singola risoluzione. Il parametro EnableOutput viene gestito in modo specifico. Per i risolutori che supportano i callback dei messaggi, impostando il valore su true il server registrerà un callback di messaggio. I messaggi risultanti verranno restituiti in SolveMathOptModelResponse.messages. Per altri risolutori, l'impostazione di EnableOutput su true comporterà un errore.
modelParameters

object (ModelSolveParametersProto)

Campo facoltativo. Parametri per controllare una singola risoluzione specifici per il modello di input (consulta SolveParametersProto per i parametri indipendenti dal modello).

Corpo della risposta

Risposta per una soluzione 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 soluzione del modello nella richiesta.
messages[]

string

Se è stato utilizzato SolveParametersProto.enable_output, questa conterrà i 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

Solving Constraint Integer Programs (SCIP) risolutore (di terze parti).

Supporta problemi quadratici con numeri interi non convessi, LP, MIP. Tuttavia, non vengono restituiti dati dual per gli LP. Preferisco GLOP per gli LP.
SOLVER_TYPE_GUROBI

Risolutore Gurobi (terza parte).

Supporta problemi quadratici con numeri interi non convessi, LP, MIP. Di solito è l'opzione più veloce, ma ha una licenza speciale.
SOLVER_TYPE_GLOP

Il risolutore Glop di Google.

Supporta LP con metodi primal e dual Simplex.
SOLVER_TYPE_CP_SAT

Il risolutore CP-SAT di Google.

Supporta problemi in cui tutte le variabili sono numeri interi e limitate (o implicite in modo che siano successive alla prerisoluzione). Supporto sperimentale per ridimensionare e distinguere i problemi con variabili continue.
SOLVER_TYPE_PDLP

Il risolutore PDLP di Google.

Supporta obiettivi quadratici con diagonale LP e diagonale. Utilizza i metodi del primo ordine anziché il Simplex. È in grado di risolvere problemi molto grandi.
SOLVER_TYPE_GLPK

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

Supporta MIP e LP.

Sicurezza Thread: GLPK utilizza l'archiviazione locale dei 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 Solver::Solve() da un altro thread rispetto a quello utilizzato per creare il Risolutore, ma non è documentato da GLPK e dovrebbe essere evitato.

Quando si risolve un LP con il presolver, la soluzione (e i raggi non associati) vengono restituiti solo se è stata trovata una soluzione ottimale. In caso contrario, non viene restituito nulla. Vedi glpk-5.0/doc/glpk.pdf pagina #40 disponibile su glpk-5.0.tar.gz per maggiori dettagli.
SOLVER_TYPE_OSQP

Il risolutore OSQP (Operations Splitting Quadratic Program) (di terze parti).

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

Il risolutore conico incorporato (ECOS) (di terze parti).

Supporta problemi LP e SOCP. Utilizza metodi con punti interni (barriera).
SOLVER_TYPE_SCS

Il risolutore SCS (Splitting Conic Risolutore) (di terze parti).

Supporta problemi LP e SOCP. Utilizza il metodo del primo ordine.
SOLVER_TYPE_HIGHS

Il risolutore HiGHS (di terze parti).

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

Implementazione di riferimento di MathOpt con un risolutore MIP.

Lenta/non consigliata per la produzione. Non è un risolutore LP (non sono state restituite due informazioni).

ModelProto

Un problema di ottimizzazione. MathOpt supporta: - Variabili di decisione continue e numeri interi con limiti finiti facoltativi. - Obiettivi lineari e quadratici (singoli o multipli), minimizzati o ingranditi. - Una serie di tipi di vincoli, inclusi: * Vincoli lineari * Vincoli quadratici * Vincoli del cono del secondo ordine * Vincoli logici > Vincoli SOS1 e SOS2 > Vincoli indicatore

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

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 nei modelli con più obiettivi.

Gli ID delle chiavi della mappa devono essere specificati nel formato [0, max(int64)). Ogni priorità e ogni nome non vuoto devono essere univoci e distinti dal objective principale.

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_ids sono elementi di variables.id. * Le voci della matrice non specificate sono zero. * linearConstraintMatrix.values deve essere tutti finito.
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 coni del 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))

I vincoli SOS1 nel modello prevedono che al massimo un expression può essere diverso da zero. Le voci weights facoltative sono un dettaglio di implementazione utilizzato dal risolutore per (si spera) convergere più rapidamente. Più nel dettaglio, i risolutori potrebbero (o meno) utilizzare questi pesi per selezionare decisioni con diramazione che producono nodi figlio "bilanciati".

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))

I vincoli SOS2 nel modello prevedono che al massimo due voci di expression possono essere diverse da zero e devono essere adiacenti nel loro ordine. Se weights non viene fornito, questo sarà il suo ordine lineare nell'elenco expressions; se vengono presentati weights, l'ordinamento viene preso in relazione a questi valori in ordine crescente.

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))

Vincoli di indicatori nel modello che lo applicano, se una "variabile indicatore" binaria è impostata su uno, deve essere applicato un "vincolo implicito".

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 necessariamente in aumento. Impossibile utilizzare il valore max(int64).
lowerBounds[]

number

Deve avere lunghezza uguale a #variables, valori in [-inf, inf).
upperBounds[]

number

Deve avere lunghezza uguale a #variables, valori in (-inf, inf].
integers[]

boolean

La lunghezza deve essere uguale a #variables. Il valore è false per le variabili continue e true per le variabili numeri interi.
names[]

string

Se non impostato, si presume che siano tutte stringhe vuote. In caso contrario, la lunghezza deve essere 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 è minimo, vero è massimizza
offset

number

Deve essere limitato e non NaN.
linearCoefficients

object (SparseDoubleVectorProto)

Termini di ObjectiveProto lineari nelle variabili decisionali.

Requisiti: * linearCoefficients.ids è un elemento di variablesProto.ids. * Il valore di ValueTrack non specificato corrisponde a zero. * I linearCoefficients.values devono essere tutti limitati. * linearCoefficients.values può essere zero, ma spreca spazio.
quadraticCoefficients

object (SparseDoubleMatrixProto)

Termini oggettivi che sono quadratici nelle variabili di decisione.

Requisiti in aggiunta a quelli dei messaggi SparseDoubleMatrixProto: * Ogni elemento di quadraticCoefficients.row_ids e ogni elemento di quadraticCoefficients.column_id deve essere un elemento di variablesProto.ids. * La matrice deve essere triangolare superiore: per ogni i, quadraticCoefficients.row_ids[i] <= quadraticCoefficients.column_ids[i].

Note: * I termini non memorizzati in modo esplicito hanno coefficiente zero. * Gli elementi di quadraticCoefficients.coefficients possono essere pari a zero, ma questo spreca solo spazio.
name

string

I messaggi principali possono avere requisiti di univocità in questo campo; ad esempio, consulta ModelProto.objectives e AuxiliaryObjectivesUpdatesProto.new_objectives.
priority

string (int64 format)

Per i problemi che hanno più obiettivi, la priorità di questo obiettivo rispetto agli altri (minore è 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 proto, quindi i modelli potrebbero avere temporaneamente degli 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)

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

number

La lunghezza deve essere uguale agli ID. Non può contenere NaN.

SparseDoubleMatrixProto

Una rappresentazione sparsa di una matrice di doppi.

La matrice è memorizzata come tripli 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 in ordine principale di 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 "#encoder lineare" = 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 necessariamente in aumento. Impossibile utilizzare il valore max(int64).
lowerBounds[]

number

Deve avere una lunghezza uguale ai vincoli #lineari, valori in [-inf, inf).
upperBounds[]

number

Deve avere una lunghezza uguale ai vincoli #lineari, valori in (-inf, inf].
names[]

string

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

Tutti i nomi non vuoti devono essere distinti.

QuadraticConstraintProto

Un singolo vincolo quadratico nella forma: lb <= sum{linearTerms} + sum{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 sui messaggi SparseDoubleVectorProto, richiediamo i seguenti requisiti: * linearTerms.ids sono elementi di variablesProto.ids. * I linearTerms.values devono essere tutti limitati e non NaN.

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

object (SparseDoubleMatrixProto)

Termini quadratici nelle variabili di decisione.

Oltre ai requisiti sui messaggi SparseDoubleMatrixProto, richiediamo i seguenti requisiti: * Ogni elemento di quadraticTerms.row_ids e ogni elemento di quadraticTerms.column_ids deve essere un elemento di variablesProto.ids. * La matrice deve essere triangolare superiore: per ogni i, quadraticTerms.row_ids[i] <= quadraticTerms.column_ids[i].

Note: * I termini non memorizzati in modo esplicito hanno coefficiente zero. * Gli elementi di quadraticTerms.coefficients possono essere pari a zero, ma questo determina solo uno spreco di 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] ed essere maggiore o uguale a lowerBound.
name

string

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

SecondOrderConeConstraintProto

Un singolo vincolo cono del secondo ordine nella 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 di variabili. Devono essere ordinati (in ordine crescente) con tutti gli elementi distinti.
coefficients[]

number

La lunghezza deve essere uguale agli ID. I valori devono essere limitati 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 a cui applicare il vincolo SOS: * SOS1: al massimo un elemento prende un valore diverso da zero. * SOS2: al massimo due elementi assumono valori diversi da zero e devono essere adiacenti nell'ordine ripetuto.
weights[]

number

È vuoto o di lunghezza uguale alle espressioni. Se vuoto, le ponderazioni predefinite sono 1, 2, ... Se presente, le voci devono essere univoche.
name

string

I messaggi principali possono 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: Variabile(indicatorId) = (activateOnZero ? 0 : 1) > Limite inferiore <= espressione <= Limite superiore.

Se una variabile coinvolta in questo vincolo (l'indicatore o visualizzato in expression) viene eliminata, viene trattata come se fosse impostata su zero. In particolare, l'eliminazione della variabile indicatore significa che il vincolo dell'indicatore è vuoto se activateOnZero è falso e che 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 il valore è true, se la variabile indicatore assume il valore 0, è necessario mantenere il vincolo implicito. Altrimenti, se la variabile dell'indicatore assume il valore 1, il vincolo implicito deve restare valido.
expression

object (SparseDoubleVectorProto)

Deve essere un'espressione lineare valida rispetto al modello contenitore: * Tutte le condizioni indicate in SparseDoubleVectorProto, * Tutti gli elementi di expression.values devono essere limitati, * 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, è necessario che: * variablesProto.integers[indicatorId] = true, * variablesProto.lower_bounds[indicatorId] >= 0, * variablesProto.upper_bounds[indicatorId] <= 1. Queste condizioni non vengono 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 es. timeLimit, e i parametri per un risolutore specifico, ad esempio gscip. Se un valore viene impostato 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 valore predefinito del risolutore.

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

I parametri che dipendono dal modello (ad es. la priorità di 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 deve dedicare al problema (oppure infinito, se non impostato).

Questo valore non è un limite fisso. Il tempo di risoluzione potrebbe superare leggermente questo valore. Questo parametro viene sempre passato al risolutore sottostante, pertanto non viene utilizzato il valore predefinito del risolutore.

Una durata in secondi con un massimo di nove cifre frazionarie, che 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 si tratta degli stream di output standard. Per Glop e CP-SAT, verrà visualizzato LOG(INFO).

Tieni presente che se il risolutore supporta il callback del messaggio e l'utente registra un callback, questo valore di parametro viene ignorato e non viene stampata alcuna traccia.
lpAlgorithm

enum (LPAlgorithmProto)

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

Per i problemi che non sono programmi lineari ma in cui la programmazione lineare è una sottoroutine, i risolutori possono utilizzare questo valore. Ad esempio, i risolutori MIP in genere la utilizzano solo per la risoluzione LP principale (in caso contrario utilizzano il dual Simplex).
presolve

enum (EmphasisProto)

Sforzati di semplificare il problema prima di iniziare l'algoritmo principale o il livello di sforzo predefinito del risolutore se TOPIC_UNSPECIFIED.
cuts

enum (EmphasisProto)

Cerca di ottenere un maggiore rilascio LP (solo MIP) o il livello di sforzo predefinito del risolutore se TOPIC_UNSPECIFIED.

NOTA: la disattivazione delle interruzioni potrebbe impedire ai callback di aggiungere interruzioni a MIP_NODE, questo comportamento è specifico per il risolutore.
heuristics

enum (EmphasisProto)

Tentativo di trovare soluzioni realizzabili oltre a quelle incontrate nella procedura di ricerca completa (solo MIP) o al livello di sforzo predefinito del risolutore se TOPIC_UNSPECIFIED.
scaling

enum (EmphasisProto)

Sforzo di riscalare il problema per migliorare la stabilità numerica o il livello di sforzo predefinito del risolutore se TOPIC_UNSPECIFIED.
iterationLimit

string (int64 format)

Limitare le iterazioni dell'algoritmo sottostante (ad es. pivot Simplex). Il comportamento specifico dipende dal risolutore e dall'algoritmo utilizzati, ma spesso può fornire un limite di risoluzione deterministico (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 legato). Per molti risolutori, può essere utilizzata per limitare in modo deterministico il calcolo (potrebbe essere necessaria un'ulteriore configurazione, ad esempio un thread).

In genere per i risolutori MIP, vedi anche itrationLimit.
cutoffLimit

number

Il risolutore si ferma presto se è in grado di dimostrare che non esistono soluzioni primordiali valide almeno quanto il valore limite.

In caso di interruzione anticipata, il risolutore restituisce il motivo della risoluzione NO_SOLUTION_FOUND e il limite CUTOFF e non è necessario fornire ulteriori informazioni sulla soluzione. Non ha alcun effetto sul valore restituito in assenza di un'interruzione anticipata.

Ti consigliamo di utilizzare una tolleranza se vuoi che vengano restituite soluzioni con lo scopo esattamente uguale al limite massimo.

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

number

Il risolutore si ferma presto non appena trova una soluzione almeno questa buona, con un motivo di risoluzione FEASIBILE e un limite OBIETTIVO.
bestBoundLimit

number

Il risolutore si ferma presto non appena dimostra che il limite migliore è almeno questo buono, con il motivo della risoluzione FEASIBLE o NO_SOLUTION_FOUND e il limite OBJECTIVE.

Consulta la guida dell'utente per maggiori dettagli e un confronto con CuoffLimit.
solutionLimit

integer

Il risolutore si ferma presto dopo aver trovato queste tante soluzioni fattibili, con il motivo della risoluzione FEASIBILE e la SOLUZIONE limitata. Deve essere maggiore di zero, se impostato. Spesso viene utilizzato per indurre il risolutore a fermarsi sulla prima soluzione possibile trovata. Tieni presente che non esiste alcuna garanzia sul valore obiettivo per nessuna delle soluzioni restituite.

I risolutori solitamente non restituiscono più soluzioni rispetto al limite consentito, ma questo non viene applicato da MathOpt, vedere anche b/214041169.

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

integer

Se impostato, deve essere >= 1.
randomSeed

integer

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

Sebbene tutti i risolutori abbiano un concetto di origine, 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

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

Il GAP assoluto è il valore assoluto della differenza tra: * il valore obiettivo della migliore soluzione possibile trovata, * il doppio vincolo prodotto dalla ricerca. Il risolutore può arrestarsi quando il GAP assoluto è al massimo assolutaGapTolerance (se impostata) e restituisce TERMINATION_REASON_OPTIMAL.

Deve essere >= 0, se impostato.

Vedi anche relativeGapTolerance.
relativeGapTolerance

number

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

Il GAP relativo è una versione normalizzata del GAP assoluto (definito su absoluteGapTolerance), in cui la normalizzazione dipende dal risolutore, ad esempio il GAP assoluto diviso per il valore obiettivo della migliore soluzione possibile trovata.

Il risolutore può arrestarsi quando il GAP relativo raggiunge al massimo la relativa tolleranza di Gap (se impostata) e restituisce TERMINATION_REASON_OPTIMAL.

Deve essere >= 0, se impostato.

Vedi anche absoluteGapTolerance.
solutionPoolSize

integer

Gestisci fino a solutionPoolSize soluzioni durante la ricerca. Il pool di soluzioni generalmente ha 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 le 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 esempio con le n soluzioni migliori, richiede un'ulteriore configurazione specifica del risolutore.

LPAlgorithmProto

Seleziona un algoritmo per risolvere programmi lineari.

Enum
LP_ALGORITHM_UNSPECIFIED
LP_ALGORITHM_PRIMAL_SIMPLEX Il metodo simplex (principale). Tipicamente può fornire soluzioni primali e doppi, raggi primoli/doppi su problemi primitivi/doppi illimitati e una base.
LP_ALGORITHM_DUAL_SIMPLEX Il metodo dual simplex. Tipicamente può fornire soluzioni primali e doppi, raggi primoli/doppi su problemi primitivi/doppi illimitati e una base.
LP_ALGORITHM_BARRIER Il metodo della barriera, comunemente chiamato anche metodo interno del punto (IPM). In genere può fornire soluzioni sia primali che doppie. Alcune implementazioni possono produrre raggi anche su problemi illimitati/impossibili. Non viene fornita una base a meno che il risolutore sottostante non faccia un "crossover" e finisca con un Simplex.
LP_ALGORITHM_FIRST_ORDER Un algoritmo basato su un metodo del primo ordine. che producono in genere sia soluzioni primali che doppie e potenzialmente anche certificati di irrilevanza primale e/o doppia. I metodi del primo ordine in genere forniscono soluzioni con minore accuratezza, quindi gli utenti dovrebbero fare 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 (per l'utilizzo, consulta SolveParametersProto).

L'enfasi viene utilizzata per configurare una funzionalità del risolutore come segue: * Se un risolutore non supporta la funzionalità, sarà sempre valida solo UNSPECIFIED, mentre qualsiasi altra impostazione genera in genere un errore relativo a un argomento non valido (alcuni risolutori possono accettare anche OFF). * Se il risolutore supporta la funzionalità: - Se l'opzione è impostata su UNSPECIFIED, viene utilizzato il valore predefinito sottostante. - Se non è possibile disattivare la funzione, l'opzione OFF restituirà un errore. - Se la funzionalità è abilitata per impostazione predefinita, il valore predefinito del risolutore è in genere mappato su MEDIUM. - Se la funzione è supportata, i valori BASSO, MEDIO, ALTO e MOLTO ALTO non restituiranno mai un errore e verranno associati alla loro 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 basati su variabili in PrimalSolutionProto e PrimalRayProto (PrimalSolutionProto.variable_values, PrimalRayProto.variable_values).

Requisiti: * Gli ID filtrati sono elementi di variablesProto.ids.
dualValuesFilter

object (SparseVectorFilterProto)

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

Requisiti: * Gli ID filtrati sono elementi di LinearConstraints.ids.
reducedCostsFilter

object (SparseVectorFilterProto)

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

Requisiti: * Gli ID filtrati sono elementi di variablesProto.ids.
initialBasis

object (BasisProto)

Base iniziale facoltativa per i risolutori LP Simplex con avvio tiepido. Se impostato, dovrebbe essere valido in base al criterio ValidateBasis in validators/solution_validator.h per l'attuale ModelSummary.
solutionHints[]

object (SolutionHintProto)

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

object (SparseInt32VectorProto)

Priorità di diramazione facoltative. Le variabili con valori più elevati verranno diramate all'inizio. Le variabili per le quali non sono impostate priorità ricevono la priorità predefinita del risolutore (di solito pari a zero).

Requisiti: * branchingPriorities.values deve essere limitato. * RamingPriorities.id deve essere elementi di variablesProto.ids.

SparseVectorFilterProto

Questo messaggio consente di interrogare/impostare parti specifiche di uno SparseXxxxVector. Il comportamento predefinito non prevede l'esclusione di nulla. Un utilizzo comune è eseguire query solo su parti di soluzioni (solo valori diversi da zero e/o solo un insieme selezionato di valori di variabili).

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

boolean

Per SparseBoolVectorProto il valore "zero" è false.
filterByIds

boolean

Se true, restituisci solo i valori corrispondenti agli ID elencati in filterIds.
filteredIds[]

string (int64 format)

L'elenco di ID da utilizzare quando filterByIds è true. Deve essere vuoto quando il valore di filterByIds è false. NOTA: se il valore è vuoto e il valore di filterByIds è true, significa che non vuoi visualizzare alcuna informazione nel risultato.

BasisProto

Caratterizzazione combinatoria di una soluzione di un programma lineare.

Il metodo Simplex per risolvere programmi lineari restituisce sempre una "soluzione di base fattibile" che può essere descritta combinatorialmente da una Base. Una base assegna un valore BaseStatusProto a ogni variabile e vincolo lineare.

Ad esempio, considera un LP in forma standard: min c * x s.t. A * x = b x >= 0 che ha più variabili dei vincoli e con ranking A per riga intera.

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 FISSO. * Scegli m variabili in modo che le colonne A siano linearmente indipendenti e assegni lo stato BASE. * Assegna lo stato AT_LOWER per le restanti variabili n - m.

La soluzione di base è l'unica soluzione di A * x = b con tutte le variabili con stato AT_LOWER fissi sui limiti inferiori (tutte zero). La soluzione risultante è chiamata soluzione fattibile di base se soddisfa anche x >= 0.

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

object (SparseBasisStatusVector)

Stato della base di vincolo.

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

object (SparseBasisStatusVector)

Stato di base variabile.

Requisiti: * constraintsStatus.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 gli LP su un solo lato deve corrispondere allo stato di fattibilità della soluzione doppia associata. Per gli LP a due lati, il processo potrebbe essere diverso in alcuni casi limite (ad es. in caso di soluzioni incomplete con un Simplex primordiale).

Se fornisci 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)

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

enum (BasisStatusProto)

La lunghezza deve essere uguale agli ID.

BasisStatusProto

Stato di una variabile o di un vincolo in base alla pagina di destinazione.

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

SolutionStatusProto

Fattibilità di una soluzione originale o doppia secondo il risolutore.

Enum
SOLUTION_STATUS_UNSPECIFIED Valore di Guard che non rappresenta alcuno stato.
SOLUTION_STATUS_UNDETERMINED Il risolutore non dichiara lo 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 attuabili. In questi casi, i risolutori di solito risolvono un MIP secondario per completare/correggere il suggerimento.

Il modo in cui il suggerimento viene utilizzato dal risolutore dipende molto 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 LP Simplex di solito preferiscono una base iniziale a un suggerimento di soluzione (in caso contrario, devono eseguire 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 sono elementi di variablesProto.ids. * variabiliValues.values devono essere tutti limitati.
dualValues

object (SparseDoubleVectorProto)

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

Requisiti: * dualValues.ids sono elementi di LinearConstraintsProto.ids. * dualValues.values devono essere tutti limitati.

SparseInt32VectorProto

Una rappresentazione sparsa di un vettore di interi.

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

string (int64 format)

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

integer

La lunghezza deve essere uguale agli ID.

SolveResultProto

Il contratto relativo ai casi in cui le soluzioni/raggi primali/doppi sono complessi, vedi terminazioni_reasons.md per una descrizione completa.

Fino a quando non viene finalizzato un contratto esatto, è più sicuro semplicemente verificare se è presente una soluzione o un raggio, anziché 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 per definire l'ordine delle soluzioni che i futuri risolutori dovrebbero implementare prevede che: 1. Le soluzioni con una soluzione possibile primordiale, ordinate per primo in base al miglior obiettivo primario. 2. Le soluzioni con una duplice soluzione fattibile, ordinate per migliore duplice obiettivo (il duplice obiettivo sconosciuto è il peggiore) 3. Tutte le soluzioni rimanenti possono essere restituite in qualsiasi ordine.
primalRays[]

object (PrimalRayProto)

Istruzioni per il miglioramento primordiale illimitato, o, equivalentemente, per i certificati di fattibilità doppi. Di solito fornito per ResolutionReasonProtos UNBOUNDED e DUAL_INFEASIBLE
dualRays[]

object (DualRayProto)

Istruzioni per il doppio miglioramento illimitato o, equivalentemente, per certificati di fattibilità primitivi. Di solito viene fornito per Motivo della Estinzione Proto INFEASIBILE.
solveStats

object (SolveStatsProto)

Statistiche sul processo di risoluzione, ad esempio tempo di esecuzione, 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)

Informazioni aggiuntive in limit quando 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 sono in grado di determinare sempre il limite che ha causato la risoluzione. Se non è possibile determinarne la causa, viene utilizzato LIMIT_UNDETERMINED.
detail

string

Informazioni aggiuntive tipicamente specifiche per il risolutore in merito 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, il parametro problemStatus si trova 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, il campo goalBounds.primal_bound è disponibile in SolveResultProto.solve.stats.best_primal_bound e goalBounds.dual_bound sono disponibili in SolveResultProto.solve.stats.best_dual_bound

TerminationReasonProto

Il motivo per cui una chiamata a Solve() viene terminata.

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

Il problema è stato risolto con uno dei criteri di cui sopra (Ottimal, Infeasible, Illimitata o InfeasibleOrUnbounded), ma una o più tolleranze non sono state soddisfatte. Alcune soluzioni/raggi primitivi/doppi sono presenti, ma saranno leggermente inattuabili oppure (se il problema era quasi ottimale) potrebbero esserci un divario tra il miglior obiettivo della soluzione e il migliore vincolo per l'obiettivo.

Gli utenti possono comunque eseguire query su soluzioni/raggi e statistiche di soluzioni primarie/due, ma sono responsabili della gestione dell'imprecisione numerica.
TERMINATION_REASON_FEASIBLE L'ottimizzatore ha raggiunto un qualche tipo di limite e viene restituita una soluzione prima possibile. Consulta SolveResultProto.limit_detail per una descrizione dettagliata del tipo di limite che è stato raggiunto.
TERMINATION_REASON_NO_SOLUTION_FOUND L'ottimizzatore ha raggiunto un qualche tipo di limite e non ha trovato una soluzione inizialmente fattibile. Consulta SolveResultProto.limit_detail per una descrizione dettagliata del tipo di limite che è stato raggiunto.
TERMINATION_REASON_NUMERICAL_ERROR L'algoritmo si è interrotto perché si è verificato un errore numerico irreversibile. Nessuna informazione sulla soluzione disponibile.
TERMINATION_REASON_OTHER_ERROR L'algoritmo si è interrotto a causa di un errore non contemplato da uno degli stati definiti sopra. Nessuna informazione sulla soluzione disponibile.

LimitProto

Quando un metodo Solve() si arresta in anticipo con TerminaReasonProto FEASIBLE o NO_SOLUTION_FOUND, il limite specifico che è stato raggiunto.

Enum
LIMIT_UNSPECIFIED Utilizzato come valore null quando abbiamo terminato da un limite diverso da un limite (ad es. TERMINATION_REASON_OPTIMAL).
LIMIT_UNDETERMINED Il risolutore sottostante non indica quale limite è stato raggiunto.
LIMIT_ITERATION Un algoritmo iterativo si è interrotto dopo aver eseguito il numero massimo di iterazioni (ad es. iterazioni simplex o di barriera).
LIMIT_TIME L'algoritmo si è arrestato dopo un tempo di calcolo specificato dall'utente.
LIMIT_NODE Un algoritmo ramo e associato è stato interrotto perché ha esplorato un numero massimo di nodi nell'albero ramo e associato.
LIMIT_SOLUTION L'algoritmo si è interrotto perché ha trovato il numero di soluzioni richiesto. Questo viene spesso utilizzato nelle MIP per fare in modo che il risolutore restituisca la prima soluzione possibile che incontra.
LIMIT_MEMORY L'algoritmo si è interrotto perché ha esaurito la memoria.
LIMIT_CUTOFF Il risolutore è stato eseguito con un limite (ad es. era stato impostato SolveParameters.cutoff_limit) per l'obiettivo, il che indicava che l'utente non voleva alcuna soluzione peggiore della soglia limite e il risolutore ha concluso che non c'erano soluzioni almeno pari al limite. In genere non vengono fornite ulteriori informazioni sulla soluzione.
LIMIT_OBJECTIVE L'algoritmo si è arrestato 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 è stato interrotto a causa di un indicatore di interruzione o di una richiesta di interruzione dell'utente.
LIMIT_SLOW_PROGRESS L'algoritmo si è interrotto perché non è stato possibile continuare a fare progressi verso la soluzione.
LIMIT_OTHER

L'algoritmo è stato interrotto a causa di un limite non coperto da uno dei suddetti limiti. 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 potrebbe contenere informazioni aggiuntive sul limite.

ProblemStatusProto

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

  • uno stato fattibile per i problemi primitivi e doppi indica che il primo è fattibile e limitato e probabilmente ha una soluzione ottimale (garantita per problemi senza vincoli non lineari).
  • uno stato primordiale fattibile e uno stato doppio non fattibile indicano che il problema primordiale è illimitato (ossia ha soluzioni arbitrariamente buone).

Tieni presente che un doppio stato impossibile di per sé (ad esempio accompagnato da uno stato primordiale indeterminato) non implica che il problema primordiale sia illimitato perché entrambi i problemi potrebbero essere irrealizzabili. Inoltre, anche se uno stato primordiale e doppio fattibile può suggerire l'esistenza di una soluzione ottimale, non garantisce che il risolutore abbia effettivamente trovato questa soluzione ottimale.

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

enum (FeasibilityStatusProto)

Stato del problema primordiale.
dualStatus

enum (FeasibilityStatusProto)

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

boolean

Se il problema è vero, il risolutore sostiene che il problema primordiale o il doppio non è fattibile, ma non sa quale (o se entrambi sono irrealizzabili). Può essere true solo se 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 infattibilità, assenza di limitazioni o a entrambi).

FeasibilityStatusProto

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

Enum
FEASIBILITY_STATUS_UNSPECIFIED Valore di Guard che non rappresenta alcuno 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 sostiene che il valore ottimale è uguale o migliore (più piccolo per minimizzazione e maggiore per massimizzazione) rispetto alla tolleranza di fattibilità primale del risolutore (vedi l'avviso sotto): * primalBound è banale (+inf per minimizzazione e -inf maximization) quando il risolutore non dichiara di avere tale limite. * primalBound può essere più vicino al valore ottimale rispetto all'obiettivo della migliore soluzione primale fattibile. In particolare, primalBound può non essere banale anche quando non vengono restituite soluzioni primarie fattibili. Avviso: l'affermazione esatta è che esiste una soluzione primordiale che: * è numericamente fattibile (ovvero fattibile fino alla tolleranza del risolutore) e che * ha un valore primalBound oggettivo. Questa soluzione numericamente fattibile potrebbe essere leggermente impossibile, nel qual caso primalBound potrebbe essere strettamente migliore del valore ottimale. Tradurre una tolleranza di fattibilità primale in una tolleranza sul primalBound 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 (maggiore per minimizzazione e minore per massimizzazione) rispetto a dualBound fino alla doppia tolleranza di fattibilità del risolutore (vedi l'avviso sotto): * dualBound è banale (-inf per minimizzazione e +inf maximization) quando il risolutore non dichiara di avere tale limite. Analogamente a primalBound, questo può accadere per alcuni risolutori anche quando restituiscono ottimale. I risolutori MIP in genere segnalano un limite anche se è impreciso. * Per problemi continui, DualBound può essere più vicino al valore ottimale che all'obiettivo della migliore soluzione doppia possibile. Per quanto riguarda MIP, uno dei primi valori non banali di dualBound è spesso il valore ottimale del rilassamento LP della MIP. * DualBound dovrebbe essere migliore (più piccolo per minimizzare e più grande per massimizzazione) rispetto al primalBound fino alle tolleranze del risolutore (vedi l'avviso di seguito). Attenzione: * per problemi continui, l'affermazione precisa è che esiste una duplice soluzione che: * è numericamente fattibile (ossia fattibile fino alla tolleranza del risolutore) e * ha un valore obiettivo dualBound. Questa soluzione numericamente fattibile potrebbe essere leggermente impossibile, nel qual caso dualBound potrebbe essere strettamente inferiore al valore ottimale e primalBound. Come nel caso primordiale, tradurre una duplice tolleranza di 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 esempio, per PDLP, pdlp_output.convergence_information. corrected_dual_objective). * Per i risolutori MIP, dualBound può essere associato a una soluzione doppia per un po' di rilassamento continuo (ad es. il rilassamento LP), ma è spesso una conseguenza complessa dell'esecuzione dei risolutori ed è in genere più impreciso dei limiti riportati dai risolutori LP.

SolutionProto

Gli elementi inclusi in una soluzione dipendono dal tipo di problema e dal risolutore. Gli attuali pattern comuni sono 1. I risolutori MIP restituiscono solo una soluzione primitiva. 2. I risolutori LP Simplex spesso restituiscono una base e le soluzioni primali e doppie associate a questa base. 3. Altri risolutori continui spesso restituiscono una soluzione doppia e primale connessa in modo dipendente dal risolutore.

Requisiti: * deve essere impostato almeno un campo. La 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 esempio, considera un programma lineare semplice: min c * x s.t. A * x >= b x >= 0. Una soluzione principale è l'assegnazione di valori a x. È fattibile se soddisfa A * x >= b e x >= 0 di cui sopra. Nel messaggio PrimalSolutionProto riportato di seguito, variabileValues è x e goalValue è c * x.

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

object (SparseDoubleVectorProto)

Requisiti: * variabiliValues.ids sono elementi di variablesProto.ids. * variabiliValues.values devono essere tutti limitati.
objectiveValue

number

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

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

Valori degli obiettivi ausiliari calcolati dal risolutore sottostante. Le chiavi devono essere ID obiettivo 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 di un problema di ottimizzazione.

Ad esempio, considera la coppia di programmi lineari a due coppie principali: (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 descritti sopra (Dual).

Nel messaggio seguente, y è doppioValues, r è ridottoCosti e b * y è il 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 devono essere tutti limitati.
reducedCosts

object (SparseDoubleVectorProto)

Requisiti: * reduceCosts.id sono elementi di variablesProto.ids. * I valori ridotti per i valori ridotti devono essere tutti limitati.
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; equivalente a un certificato di non fattibilità per il duplice del problema di ottimizzazione.

Ad esempio, consideriamo un semplice programma lineare: min c * x s.t. A * x >= b x >= 0 Un raggio primole è una x che soddisfa: c * x < 0 A * x >= 0 x >= 0 Un raggio primordiale dimostra inoltre che il problema della duplice ottimizzazione è impossibile.

Nel messaggio PrimalRay riportato di seguito, variabileValues è x.

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

object (SparseDoubleVectorProto)

Requisiti: * variabiliValues.ids sono elementi di variablesProto.ids. * variabiliValues.values devono essere tutti limitati.

DualRayProto

Direzione di miglioramento illimitato al duplice di un problema di ottimizzazione; equivalente a un certificato di infattibilità primordiale.

Ad esempio, considera la coppia di programmi lineari a due coppie principali: (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 raggio doppio è la coppia (y, r) soddisfatta: Il doppio raggio dimostra inoltre che il problema primordiale è impossibile.

Nel messaggio DualRay riportato di seguito, y è dualValues e r è reduceCosts.

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

object (SparseDoubleVectorProto)

Requisiti: * dualValues.ids sono elementi di LinearConstraints.ids. * dualValues.values devono essere tutti limitati.
reducedCosts

object (SparseDoubleVectorProto)

Requisiti: * reduceCosts.id sono elementi di variablesProto.ids. * I valori ridotti per i valori ridotti devono essere tutti limitati.

SolveStatsProto

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

string (Duration format)

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

Una durata in secondi con un massimo di nove cifre frazionarie, che 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)