Calcolatore di punto angolare
Inserisca i coefficienti della funzione obiettivo e i vertici della regione ammissibile e veda quale dà il valore più alto: per 3x + 5y su (0, 0), (0, 4), (3, 3) e (5, 0) vince (3, 3), con 24. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Obiettivo
- 3, 5
- Vertice ottimo
- 3, 3
- Valore obiettivo
- 24
- Indice
- 2
- Vertici valutati
- 4
Il calcolatore del vertice ottimo risponde all'ultimo passo di qualsiasi esercizio di programmazione lineare: dati i coefficienti obiettivo e i vertici della regione ammissibile, quale vertice massimizza l'obiettivo e quale valore raggiunge? Un obiettivo lineare su un politopo convesso raggiunge sempre l'ottimo in un vertice, quindi valutare l'obiettivo in ogni vertice e conservare il migliore non è un'approssimazione: è la soluzione esatta. L'esecuzione richiede millisecondi, non conserva nulla, e lo stesso codice gira gratuitamente nel Suo browser su questa pagina.
Perché l'ottimo è sempre un vertice
Il teorema fondamentale della programmazione lineare afferma che se un programma lineare ha una soluzione ottima e la sua regione ammissibile ha almeno un vertice, allora esiste un vertice ottimo. Un obiettivo lineare si muove lungo insiemi di livello paralleli; spingendo tali insiemi nella direzione di miglioramento, si finisce per premerli contro un punto estremo del politopo ammissibile. Ecco perché i metodi classici — la soluzione grafica in due variabili, il metodo del simplesso in dimensioni superiori — ragionano esclusivamente sui vertici.
Se ha già enumerato i vertici della Sua regione ammissibile, il lavoro rimanente è puramente aritmetico: calcolare c·x in ogni vertice e scegliere il più grande. Poiché valuta ogni vertice, Le indica anche quanti candidati sono stati confrontati, utile quando verifica una soluzione o insegna il metodo passo dopo passo.
Preparare i vertici a partire dai vincoli
L'input è volutamente semplice: un array obiettivo e un array di vertici, dove ogni vertice è un array di numeri della stessa lunghezza dell'obiettivo. Ottenere quei vertici spetta a Lei — in genere intersecando coppie di rette di vincolo in due dimensioni, oppure con una routine di enumerazione dei vertici in dimensioni superiori. Le parità sono deterministiche: quando due vertici raggiungono lo stesso valore massimo, vince quello che compare per primo nell'elenco, quindi chiamate ripetute con lo stesso input restituiscono sempre la stessa risposta, byte per byte.
Leggere il risultato e automatizzarlo
L'indice è importante in pratica perché i vertici di solito hanno etichette nel Suo modello — mix di macchine A, portafoglio B — e la posizione Le permette di ricollegare la risposta senza fragili confronti di coordinate. Le automazioni tipiche includono la correzione di compiti di studenti rispetto a una soluzione di riferimento, la verifica che l'ottimo riportato da un solver coincida con un'enumerazione indipendente dei vertici, e la valutazione di piccoli modelli di pianificazione o miscelazione in cui enumerare i vertici costa meno che distribuire un solver LP completo.
Casi d'uso
Concludere un esercizio grafico di PL
Dopo aver trovato a mano i vertici ammissibili di un problema a due variabili, confermi quale massimizza il profitto senza rifare i calcoli.
Correggere compiti di ottimizzazione su larga scala
Automatizzi il confronto tra i vertici inviati dallo studente e la risposta di riferimento, con una chiamata deterministica per elaborato.
Domande frequenti
Quanto costa?
È anche gratuito nel browser su questa pagina: lo stesso codice viene eseguito in entrambi i casi.
E se più vertici raggiungono lo stesso massimo?
Vince il primo dell'elenco. La regola di parità è deterministica, quindi lo stesso input produce sempre la stessa risposta.
Verifica che i miei vertici soddisfino i vincoli?
No. Non vede mai i Suoi vincoli: si fida dell'elenco di vertici che invia. L'ammissibilità va stabilita quando enumera i vertici.
Quali dimensioni sono supportate?
Qualsiasi dimensione da 1 fino al limite documentato, purché ogni vertice abbia esattamente la stessa lunghezza dell'array obiettivo.
Perché l'ottimo di un problema lineare si trova sempre in un vertice?
Perché una funzione obiettivo lineare migliora sempre nella stessa direzione e, spingendola fin dove la regione ammissibile lo consente, si arriva a un punto estremo. Se esiste una soluzione ottima e la regione ha almeno un vertice, uno dei vertici è ottimo.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/math/corner-point \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"objective":[3,5],"vertices":[[0,0],[0,4],[3,3],[5,0]]}'const res = await fetch("https://api.kit.forhosting.com/math/corner-point", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"objective": [
3,
5
],
"vertices": [
[
0,
0
],
[
0,
4
],
[
3,
3
],
[
5,
0
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/corner-point",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"objective": [
3,
5
],
"vertices": [
[
0,
0
],
[
0,
4
],
[
3,
3
],
[
5,
0
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/corner-point", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"objective":[3,5],"vertices":[[0,0],[0,4],[3,3],[5,0]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"objective":[3,5],"vertices":[[0,0],[0,4],[3,3],[5,0]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/corner-point", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"objective": [
3,
5
],
"vertices": [
[
0,
0
],
[
0,
4
],
[
3,
3
],
[
5,
0
]
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.corner_point",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_rows | 4096 |
max_cols | 64 |
max_abs | 1000000000000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Lei invia il vettore dei coefficienti e l'elenco dei vertici; l'endpoint valuta il prodotto scalare in ogni vertice, applica una regola deterministica in caso di parità e restituisce il vertice vincente, il suo valore obiettivo e la sua posizione nell'elenco.
Perché l'ottimo è sempre un vertice
Questo endpoint fa esattamente questo, con una convalida rigorosa, così un vertice malformato o una dimensione incoerente generano un errore esplicito invece di corrompere silenziosamente il risultato.
Preparare i vertici a partire dai vincoli
Ogni vertice inviato deve essere ammissibile; l'endpoint si fida dell'elenco fornito e non riverifica i vincoli, perché non li vede mai. Ogni coordinata deve essere un numero finito entro il limite di magnitudine documentato, e un elenco di vertici vuoto viene rifiutato con un errore invalid_input, poiché una regione senza vertici non offre nulla da ottimizzare.
Leggere il risultato e automatizzarlo
La risposta contiene quattro campi: optimal_vertex, una copia delle coordinate vincenti; objective_value, il massimo c·x raggiunto; index, la posizione in base zero di quel vertice nell'array inviato; e vertices_evaluated, il numero di candidati confrontati.
Casi di integrazione
Verificare un solver LP
Invii all'endpoint un elenco di vertici enumerato in modo indipendente insieme all'obiettivo e verifichi che l'ottimo del solver coincida.
Domande tecniche
Cosa succede con un elenco di vertici vuoto?
La richiesta viene rifiutata con un errore invalid_input e non viene addebitata: senza vertici non c'è nulla da ottimizzare.
Può minimizzare invece di massimizzare?
Inverta il segno dei coefficienti obiettivo e dell'objective_value restituito: massimizzare −c·x equivale a minimizzare c·x.