Multiplicação de polinômios
Expanda um produto de polinômios sem erros: (1 + 2x) vezes (3 + 4x) é 3 + 10x + 8x², e o grau do produto, 2, é a soma dos graus. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Roda direto no seu navegador. Grátis, sem cadastro — seus dados não são enviados para lugar nenhum.
Uma calculadora de multiplicação de polinômios transforma duas listas de coeficientes no produto expandido dos polinômios correspondentes. Informe p e q como arrays de números com o termo constante primeiro—assim [1, 2] significa 1 + 2x e [3, 4] significa 3 + 4x—e a ferramenta devolve os coeficientes do produto, strings de polinômio legíveis, graus de ambos os fatores e do produto, e notas de convolução passo a passo. Checagens de lição, preparação de provas, valores esperados de kata de código e demos de processamento de sinais precisam da mesma convolução discreta sem abrir um sistema de álgebra computacional.
O que listas de coeficientes significam e como o produto é formado
Um polinômio univariado fica completamente determinado por sua sequência de coeficientes reais uma vez fixada a convenção de ordenação. Esta ferramenta usa a convenção termo-constante-primeiro que domina programação e bibliotecas numéricas: o array [a0, a1, a2, …, am] representa a0 mais a1 vezes x mais a2 vezes x ao quadrado, até am vezes x à m. A segunda entrada usa a mesma convenção.
Essa soma é exatamente a convolução discreta das duas sequências, e seu comprimento é sempre len(p) mais len(q) menos um antes de eliminar zeros finais para exibição. O grau formal é o maior índice cujo valor absoluto está acima de um épsilon minúsculo, de modo que uma lista que termina com poeira numérica ainda reporta o grau matemático correto. O polinômio zero—todo coeficiente zero após arredondamento—é permitido como fator ou como produto, e seu grau é reportado como menos um pela convenção algébrica usual.
Dicas práticas, limites e buscas relacionadas
Mantenha magnitudes de coeficientes dentro da faixa absoluta publicada para que produtos por pares não transbordem para um termo de convolução não finito que o solucionador deva rejeitar. Zeros finais em uma lista de entrada são preservados nos arrays ecoados mas não inflacionam o grau formal após a checagem de épsilon; o comprimento do produto ainda segue o comprimento completo de convolução para que o alinhamento de índices permaneça previsível em testes unitários.
Checagens clássicas de sala incluem (1 + x) vezes (1 + x) igual a 1 + 2x + x ao quadrado, (2 + 3x) vezes (4 − x) igual a 8 + 10x − 3x ao quadrado, e uma constante vezes qualquer polinômio escala cada coeficiente. Este landing mira pessoas que buscam calculadora de multiplicação de polinômios, multiplicar dois polinômios por coeficientes ou expandir um produto de polinômios online; não é um multiplicador multivariado, nem um fatorador, nem um buscador de raízes.
Prefira esta capacidade quando já tiver ambos os vetores de coeficientes e só precisar do produto expandido; se sua fonte for uma expressão escrita, analise coeficientes primeiro. Checagens de ida e volta são fáceis: recalcule à mão algumas entradas product[k] pela fórmula de convolução e confirme que coincidem com o array product publicado no mesmo arredondamento a doze casas.
Casos de uso
Checagens de lição ao expandir produtos
Alunos inserem duas listas de coeficientes de problemas de livro e comparam produtos expandidos à mão, graus e strings legíveis com um resultado determinístico antes de entregar.
Demos de sinal e controle com convolução FIR
Pipelines tratam respostas ao impulso FIR curtas como polinômios e as multiplicam para cascata de filtros, usando o mesmo produto de coeficientes sem dependência de CAS.
Perguntas frequentes
Como os coeficientes são ordenados?
Termo constante primeiro: [a0, a1, a2] significa a0 + a1·x + a2·x². O produto usa a mesma ordem de baixo para alto.
O que acontece se alguma lista estiver vazia?
Um array vazio é dado faltante, não o polinômio zero.
O produto elimina zeros finais?
O array product mantém o comprimento completo de convolução (len(p)+len(q)−1). O grau formal ignora quase-zeros finais para o campo degree e a string de impressão.
Posso multiplicar mais de dois polinômios?
Não em uma chamada. Multiplique aos pares: alimente o produto do primeiro par como p para o próximo fator.
A calculadora de multiplicação de polinômios é gratuita?
A ferramenta do navegador é gratuita e roda localmente.
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/algebra/polynomial-multiply \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"p":[1,2],"q":[3,4]}'const res = await fetch("https://api.kit.forhosting.com/algebra/polynomial-multiply", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"p": [
1,
2
],
"q": [
3,
4
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/polynomial-multiply",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"p": [
1,
2
],
"q": [
3,
4
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/polynomial-multiply", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"p":[1,2],"q":[3,4]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"p":[1,2],"q":[3,4]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/polynomial-multiply", 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
{
"p": [
1,
2
],
"q": [
3,
4
]
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_multiply",
"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_coeffs | 256 |
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
Listas vazias são rejeitadas com erro invalid_input claro em vez de inventar um polinômio zero por silêncio. O caminho é aritmética determinística pura—sem rede, sem sementes aleatórias, sem dependência de relógio—de modo que o executor gratuito do navegador e a API pré-paga devolvem o mesmo JSON após arredondamento decimal fixo toda vez que você a chama.
O que listas de coeficientes significam e como o produto é formado
O produto algébrico de dois desses polinômios é novamente um polinômio cujo coeficiente no grau k é a soma sobre i de a_i vezes b_{k−i} para cada par de índices que permanece dentro de ambos os arrays. O que não é permitido é um array de coeficientes vazio: vazio não é polinômio zero; é dado faltante, e a API devolve invalid_input para que scripts de lição e pipelines de correção falhem ruidosamente em vez de tratar silêncio como zero.
Como chamar a API e o que volta
Envie um corpo JSON com dois arrays não vazios obrigatórios de números finitos: p (aliases poly1, a, left) e q (aliases poly2, b, right). Cada array pode ter no máximo duzentos cinquenta e seis coeficientes, e cada valor absoluto de coeficiente deve permanecer dentro de um trilhão para que produtos intermediários permaneçam finitos em precisão dupla IEEE no Worker e no navegador. Números em string são aceitos quando correspondem a um padrão numérico finito estrito; strings de array codificadas em JSON também são aceitas para clientes que só enviam campos de texto. Em caso de sucesso a resposta ecoa p e q arredondados, define product como a lista completa de coeficientes de convolução (constante primeiro), degree_p, degree_q e degree como os graus formais dos fatores e do produto, p_str, q_str e product_str como polinômios legíveis compactos com sinais sensatos e coeficientes unitários omitidos, formula como uma breve descrição em inglês da convolução de coeficientes, message como um resumo de grau em uma linha, e steps como um array ordenado de linhas de substituição que você pode afirmar em testes. Validação falha—campos ausentes, arrays vazios, não-arrays, entradas não finitas, listas maiores que o máximo publicado, valores fora dos limites absolutos ou produtos não finitos—devolve invalid_input e nunca é cobrada. O preço é um US$ 0,002 fixo por pedido bem-sucedido com item unitário e preço unitário marginal zero.
Dicas práticas, limites e buscas relacionadas
Prefira enviar arrays JSON genuínos em vez de strings pré-formatadas quando controlar o cliente. Emparelhe esses sucessos com um p vazio ou q vazio para documentar o caminho duro invalid_input. Tarefas falhas que devolvem invalid_input não consomem saldo pré-pago, o que mantém scripts exploratórios baratos quando alunos enviam deliberadamente listas vazias.
Casos de integração
Testes unitários para bibliotecas de polinômios de alunos
Gere casos de convolução conhecidos como corretos mais rejeições deliberadas de lista vazia para valores esperados de kata de código e fixtures de integração contínua.