Composição de polinômios
Substitua um polinômio dentro de outro e obtenha o resultado expandido: com f(x) = x² e g(x) = 1 + x, f(g(x)) é 1 + 2x + x², de grau 2. Cada passo aparece na tela. 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 composição de polinômios constrói o composto expandido f(g(x)) a partir de duas listas de coeficientes. Informe o polinômio externo f e o interno g com o termo constante primeiro—assim [1, 2, 1] significa 1 + 2x + x ao quadrado e [0, 1] significa x—e a ferramenta devolve os coeficientes da composição após substituir g em f, combinar termos semelhantes, cadeias de polinômio legíveis, graus formais de f, g e do composto, além de notas de Horner passo a passo. Verificações de lição de casa, preparação de provas, valores esperados de kata de código e demos de mudança de variável precisam da mesma expansão por substituição sem abrir um sistema de álgebra computacional.
O que f(g(x)) significa e como os coeficientes são ordenados
A composição de funções para polinômios significa substituição: se f associa a um valor u a expressão a0 mais a1 vezes u mais a2 vezes u ao quadrado e potências superiores, e g associa a x a expressão b0 mais b1 vezes x e potências superiores, então f de g de x é o polinômio obtido ao substituir cada ocorrência de u em f pela expressão completa de g de x, expandir produtos de potências de g e reunir potências semelhantes de x.
O resultado é de novo um polinômio univariado cujo grau formal é o produto dos graus formais de f e g quando ambos são positivos, ou zero quando f é uma constante não nula, ou menos um para o polinômio zero. Esta ferramenta usa a convenção termo-constante-primeiro que domina a programação e as 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 mesma convenção se aplica a g e ao array de composição devolvido. A expansão algébrica é feita com a forma aninhada de Horner a0 mais g vezes (a1 mais g vezes (a2 mais …)), de modo que cada passo multiplica o polinômio em curso por g e soma o próximo coeficiente externo—equivalente a expandir f de g e combinar termos semelhantes, porém com menos multiplicações intermediárias. Uma lista de coeficientes toda zero é válida e representa o polinômio zero com grau menos um.
Dicas práticas, limites e buscas relacionadas
Mantenha as magnitudes dos coeficientes dentro da faixa absoluta publicada e prefira graus modestos para que o produto dos graus fique bem abaixo do teto de comprimento do resultado. Verificações clássicas de sala incluem f igual a x ao quadrado com g igual a um mais x resultando em um mais dois x mais x ao quadrado, f igual a dois mais três x com g igual a um menos x resultando em cinco menos três x, e compor com a identidade g igual a x deixando f inalterado.
Este landing mira pessoas que buscam uma calculadora de composição de polinômios, compor dois polinômios online, expandir f de g de x ou substituir um polinômio em outro; não é um compositor multivariado, nem um fatorador, nem um buscador de raízes. Prefira esta capacidade quando você já tem ambos os vetores de coeficientes e só precisa do composto expandido; se a fonte for uma expressão escrita, analise os coeficientes primeiro. Quando só precisar do produto de dois polinômios sem substituição, use em vez disso uma ferramenta de multiplicação dedicada.
Checagens de ida e volta são fáceis: recalcule à mão alguns coeficientes de composição a partir de Horner ou expandindo potências de g e confirme que coincidem com o array composition publicado dentro do mesmo arredondamento a doze decimais.
Casos de uso
Checagens de lição ao expandir f(g(x))
Alunos informam listas de coeficientes externo e interno de problemas de composição do livro e comparam compostos expandidos à mão, graus e cadeias legíveis com um resultado determinístico antes de entregar.
Demos de mudança de variável na preparação de cálculo
Pipelines substituem uma mudança de variável linear ou quadrática em um polinômio externo de grau maior para montar exemplos de prova sem dependência de um sistema de álgebra computacional.
Perguntas frequentes
Como os coeficientes são ordenados?
Termo constante primeiro: [a0, a1, a2] significa a0 + a1·x + a2·x². A composição usa a mesma ordem do baixo para o alto.
O resultado é f(g(x)) ou g(f(x))?
Sempre f(g(x)): g é substituído em f. Troque os dois arrays se precisar da outra ordem.
O que acontece se alguma lista estiver vazia?
Um array vazio é dado ausente, não o polinômio zero.
Qual é o grau da composição?
Quando ambos os graus formais são positivos, deg(f∘g) é igual a deg(f)·deg(g). Constantes e o polinômio zero seguem as regras algébricas habituais.
A calculadora de composição de polinômios é grátis?
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-composition \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"f":[1,2,1],"g":[0,1]}'const res = await fetch("https://api.kit.forhosting.com/algebra/polynomial-composition", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"f": [
1,
2,
1
],
"g": [
0,
1
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/polynomial-composition",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"f": [
1,
2,
1
],
"g": [
0,
1
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/polynomial-composition", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"f":[1,2,1],"g":[0,1]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"f":[1,2,1],"g":[0,1]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/polynomial-composition", 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
{
"f": [
1,
2,
1
],
"g": [
0,
1
]
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_composition",
"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 | 64 |
max_result_coeffs | 1025 |
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 um 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 do relógio—de modo que o executor gratuito do navegador e a API pré-paga devolvem o mesmo JSON após arredondamento decimal fixo cada vez que você a chama.
O que f(g(x)) significa e como os coeficientes são ordenados
Arrays de coeficientes vazios não são permitidos: vazio é dado ausente, não o polinômio zero, e a API devolve invalid_input para que scripts de lição e pipelines de correção falhem de forma ruidosa.
Como chamar a API e o que retorna
O composto expandido pode ter no máximo mil e vinte e cinco coeficientes; composições cujo produto de graus ultrapassaria esse limite são rejeitadas antes do trabalho começar. Envie um corpo JSON com dois arrays não vazios obrigatórios de números finitos: f (aliases outer, p, poly_f) para o polinômio externo e g (aliases inner, q, poly_g) para o polinômio interno que é substituído em f. Cada array pode ter no máximo sessenta e quatro coeficientes, e cada valor absoluto de coeficiente deve permanecer dentro de um trilhão para que os produtos intermediários continuem finitos em precisão dupla IEEE no Worker e no navegador. Números em string são aceitos quando coincidem com 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 f e g arredondados, define composition como a lista completa de coeficientes expandidos (constante primeiro), degree_f, degree_g e degree como os graus formais dos fatores e do composto, f_str, g_str e composition_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 composição de Horner, 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, resultados oversized ou intermediários não finitos—devolve invalid_input e nunca é cobrada. O preço é um US$ 0,002 fixo por requisição bem-sucedida com unidade item.
Dicas práticas, limites e buscas relacionadas
Prefira enviar arrays JSON genuínos em vez de strings pré-formatadas quando você controla o cliente. Emparelhe esses sucessos com um f vazio ou um g vazio para documentar o caminho duro invalid_input. Tarefas falhas que devolvem invalid_input não consomem saldo pré-pago, o que mantém baratos os scripts exploratórios quando aprendizes enviam listas vazias de propósito.
Casos de integração
Testes unitários para bibliotecas de polinômios de alunos
Gere casos de composiçã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.