Calculadora de ponto de canto
Digite os coeficientes da função objetivo e os vértices da região factível e veja qual dá o maior valor: para 3x + 5y sobre (0, 0), (0, 4), (3, 3) e (5, 0), vence (3, 3), com 24. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Objetivo
- 3, 5
- Vértice ótimo
- 3, 3
- Valor objetivo
- 24
- Índice
- 2
- Vértices avaliados
- 4
A calculadora de ponto de vértice responde à etapa final de qualquer exercício de programação linear: dados os coeficientes da função objetivo e os pontos extremos da região factível, qual vértice maximiza o objetivo e qual valor ele alcança? Um objetivo linear sobre um politopo convexo sempre atinge seu ótimo em um vértice, portanto avaliar o objetivo em cada ponto extremo e ficar com o melhor não é uma aproximação — é a solução exata. Roda em milissegundos, não armazena nada, e o mesmo código roda gratuitamente no seu navegador nesta página.
Por que o ótimo é sempre um ponto de vértice
O teorema fundamental da programação linear afirma que, se um programa linear tem solução ótima e sua região factível tem pelo menos um vértice, então algum vértice é ótimo. Um objetivo linear se move em conjuntos de nível paralelos; ao empurrar esses conjuntos na direção de melhoria, eles acabam pressionados contra um ponto extremo do politopo factível. É por isso que os métodos clássicos — a solução gráfica em duas variáveis, o método simplex em dimensões maiores — raciocinam exclusivamente sobre pontos de vértice.
Se você já enumerou os vértices da sua região factível, o trabalho restante é puramente aritmético: calcule c·x em cada vértice e escolha o maior. Como avalia todos os vértices, ele também informa quantos candidatos foram comparados, o que é útil ao auditar uma solução ou ensinar o método passo a passo.
Preparando os vértices a partir das suas restrições
A entrada é deliberadamente simples: um array de objetivo e um array de vértices, em que cada vértice é um array de números com o mesmo comprimento do objetivo. Obter esses vértices é tarefa sua — normalmente pela interseção de pares de retas de restrição em duas dimensões, ou por uma rotina de enumeração de vértices em dimensões maiores.
Os empates são determinísticos: quando dois vértices atingem o mesmo valor máximo, vence o que aparece primeiro na sua lista, de modo que chamadas repetidas com a mesma entrada sempre retornam a mesma resposta, byte por byte.
Lendo o resultado e automatizando
O index importa na prática porque os vértices geralmente vêm com rótulos no seu próprio modelo — mistura de máquinas A, carteira B — e a posição permite mapear a resposta de volta sem uma comparação frágil de coordenadas. Automações típicas incluem corrigir trabalhos de alunos contra uma solução de referência, verificar se o ótimo relatado por um solver confere com uma enumeração independente de vértices e pontuar pequenos modelos de escalonamento ou mistura em que enumerar os vértices sai mais barato do que implantar um solver de LP completo.
Casos de uso
Concluir um exercício gráfico de PL
Depois de encontrar à mão os vértices factíveis de um problema de duas variáveis, confirme qual deles maximiza o lucro sem refazer as contas.
Corrigir tarefas de otimização em escala
Automatize a comparação entre os pontos de vértice enviados pelo aluno e a resposta de referência, uma chamada determinística por envio.
Perguntas frequentes
Quanto custa?
Também é gratuito rodar no seu navegador nesta página — o mesmo código é executado nos dois casos.
E se vários vértices atingirem o mesmo máximo?
Vence o primeiro da sua lista. A regra de desempate é determinística, portanto entradas idênticas sempre produzem a resposta idêntica.
Ele verifica se meus vértices satisfazem as restrições?
Não. Ele nunca vê suas restrições — confia na lista de vértices que você envia. A factibilidade deve ser garantida ao enumerar os vértices.
Quais dimensões são suportadas?
Qualquer dimensão de 1 até o limite documentado, desde que cada vértice tenha exatamente o mesmo comprimento do array de objetivo.
Por que o ótimo de um problema linear fica sempre em um vértice?
Porque uma função objetivo linear melhora sempre na mesma direção e, ao empurrá-la até onde a região factível permite, chega-se a um ponto extremo. Se existe solução ótima e a região tem algum vértice, um deles é ótimo.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"objective": [
3,
5
],
"vertices": [
[
0,
0
],
[
0,
4
],
[
3,
3
],
[
5,
0
]
]
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.corner_point",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_rows | 4096 |
max_cols | 64 |
max_abs | 1000000000000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Você envia o vetor de coeficientes e a lista de vértices; o endpoint avalia o produto escalar em cada vértice, aplica uma regra determinística de desempate e devolve o vértice vencedor, seu valor objetivo e sua posição na sua lista.
Por que o ótimo é sempre um ponto de vértice
Este endpoint faz exatamente isso, com validação rigorosa para que um vértice malformado ou uma incompatibilidade de dimensão falhe de forma explícita em vez de corromper silenciosamente o seu resultado.
Preparando os vértices a partir das suas restrições
Cada vértice enviado deve ser factível; o endpoint confia na lista fornecida e não verifica novamente as restrições, pois nunca as vê. Cada coordenada deve ser um número finito dentro do limite de magnitude documentado, e uma lista de vértices vazia é rejeitada com erro invalid_input, já que uma região factível sem pontos extremos não tem nada a otimizar.
Lendo o resultado e automatizando
A resposta traz quatro campos: optimal_vertex, uma cópia das coordenadas vencedoras; objective_value, o máximo c·x alcançado; index, a posição (começando em zero) desse vértice no array enviado; e vertices_evaluated, a contagem de candidatos comparados. O executor web desta página roda o mesmo código gratuitamente, então você pode prototipar interativamente e só pagar ao integrar a chamada em um pipeline por US$ 0,002 por requisição.
Casos de integração
Conferir um solver de LP
Envie ao endpoint uma lista de vértices enumerada de forma independente junto com o objetivo e verifique se o ótimo relatado pelo solver confere.
Perguntas técnicas
O que acontece com uma lista de vértices vazia?
A requisição é rejeitada com erro invalid_input e não é cobrada: sem pontos de vértice não há nada a otimizar.
É possível minimizar em vez de maximizar?
Negue os coeficientes do objetivo e o objective_value retornado: maximizar −c·x é o mesmo que minimizar c·x.