Composición de polinomios
Sustituya un polinomio dentro de otro y obtenga el resultado desarrollado: con f(x) = x² y g(x) = 1 + x, f(g(x)) es 1 + 2x + x², de grado 2. Cada paso queda a la vista. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Corre en su navegador. Gratis y sin límite: sus datos no salen de esta página.
Una calculadora de composición de polinomios construye el compuesto expandido f(g(x)) a partir de dos listas de coeficientes. Introduzca el polinomio exterior f y el interior g con el término constante primero—así [1, 2, 1] significa 1 + 2x + x al cuadrado y [0, 1] significa x—y la herramienta devuelve los coeficientes de la composición tras sustituir g en f, combinar términos semejantes, cadenas de polinomio legibles, grados formales de f, g y del compuesto, más notas de Horner paso a paso. Comprobaciones de deberes, preparación de exámenes, valores esperados de kata de código y demos de cambio de variable necesitan la misma expansión por sustitución sin abrir un sistema de álgebra computacional.
Qué significa f(g(x)) y cómo se ordenan los coeficientes
La composición de funciones para polinomios significa sustitución: si f asigna a un valor u la expresión a0 más a1 por u más a2 por u al cuadrado y potencias superiores, y g asigna a x la expresión b0 más b1 por x y potencias superiores, entonces f de g de x es el polinomio que se obtiene al reemplazar cada aparición de u en f por la expresión completa de g de x, expandir productos de potencias de g y reunir potencias semejantes de x.
El resultado es de nuevo un polinomio univariado cuyo grado formal es el producto de los grados formales de f y g cuando ambos son positivos, o cero cuando f es una constante no nula, o menos uno para el polinomio cero. Esta herramienta usa la convención término-constante-primero que domina la programación y las bibliotecas numéricas: el array [a0, a1, a2, …, am] representa a0 más a1 por x más a2 por x al cuadrado, hasta am por x a la m.
La misma convención se aplica a g y al array de composición devuelto. La expansión algebraica se realiza con la forma anidada de Horner a0 más g por (a1 más g por (a2 más …)), de modo que cada paso multiplica el polinomio en curso por g y suma el siguiente coeficiente exterior—equivalente a expandir f de g y combinar términos semejantes, pero con menos multiplicaciones intermedias. Una lista de coeficientes toda a cero es válida y representa el polinomio cero con grado menos uno.
Consejos prácticos, límites y búsquedas relacionadas
Mantenga las magnitudes de coeficientes dentro del rango absoluto publicado y prefiera grados modestos para que el producto de grados quede bien por debajo del tope de longitud del resultado.
Comprobaciones clásicas de aula incluyen f igual a x al cuadrado con g igual a uno más x que da uno más dos x más x al cuadrado, f igual a dos más tres x con g igual a uno menos x que da cinco menos tres x, y componer con la identidad g igual a x que deja f sin cambio.
Este aterrizaje apunta a personas que buscan una calculadora de composición de polinomios, componer dos polinomios en línea, expandir f de g de x o sustituir un polinomio en otro; no es un compositor multivariado, ni un factorizador, ni un buscador de raíces. Prefiera esta capacidad cuando ya tenga ambos vectores de coeficientes y solo necesite el compuesto expandido; si su fuente es una expresión escrita, analice primero los coeficientes. Cuando solo necesite un producto de dos polinomios sin sustitución, use en su lugar una herramienta de multiplicación dedicada.
Las comprobaciones de ida y vuelta son fáciles: recalcule a mano algunos coeficientes de composición desde Horner o expandiendo potencias de g y confirme que coinciden con el array composition publicado dentro del mismo redondeo a doce decimales.
Qué puede hacer con ella
Comprobaciones de deberes al expandir f(g(x))
Los estudiantes introducen listas de coeficientes exterior e interior de problemas de composición de libro y comparan compuestos expandidos a mano, grados y cadenas legibles con un resultado determinista antes de entregar.
Demos de cambio de variable en preparación de cálculo
Las tuberías sustituyen un cambio de variable lineal o cuadrático en un polinomio exterior de mayor grado para construir ejemplos de examen sin dependencia de un sistema de álgebra computacional.
Preguntas frecuentes
¿Cómo se ordenan los coeficientes?
Término constante primero: [a0, a1, a2] significa a0 + a1·x + a2·x². La composición usa el mismo orden de bajo a alto.
¿El resultado es f(g(x)) o g(f(x))?
Siempre f(g(x)): g se sustituye en f. Intercambie los dos arrays si necesita el otro orden.
¿Qué ocurre si alguna lista está vacía?
Un array vacío es dato faltante, no el polinomio cero.
¿Cuál es el grado de la composición?
Cuando ambos grados formales son positivos, deg(f∘g) es igual a deg(f)·deg(g). Las constantes y el polinomio cero siguen las reglas algebraicas habituales.
¿Es gratis la calculadora de composición de polinomios?
La herramienta del navegador es gratuita y se ejecuta en local.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
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)Ejemplo de solicitud
{
"f": [
1,
2,
1
],
"g": [
0,
1
]
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_composition",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_coeffs | 64 |
max_result_coeffs | 1025 |
max_abs | 1000000000000 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Las listas vacías se rechazan con un error invalid_input claro en lugar de inventar un polinomio cero por silencio. El camino es aritmética determinista pura—sin red, sin semillas aleatorias, sin dependencia del reloj—de modo que el ejecutor gratuito del navegador y la API prepago devuelven el mismo JSON tras un redondeo decimal fijo cada vez que la llama.
Qué significa f(g(x)) y cómo se ordenan los coeficientes
No se permiten arrays de coeficientes vacíos: vacío es dato faltante, no el polinomio cero, y la API devuelve invalid_input para que scripts de deberes y tuberías de calificación fallen ruidosamente.
Cómo llamar a la API y qué vuelve
El compuesto expandido puede tener como máximo mil veinticinco coeficientes; las composiciones cuyo producto de grados superaría ese límite se rechazan antes de empezar el trabajo. Envíe un cuerpo JSON con dos arrays no vacíos obligatorios de números finitos: f (alias outer, p, poly_f) para el polinomio exterior y g (alias inner, q, poly_g) para el polinomio interior que se sustituye en f. Cada array puede tener como máximo sesenta y cuatro coeficientes, y cada valor absoluto de coeficiente debe permanecer dentro de un billón para que los productos intermedios sigan siendo finitos en precisión doble IEEE en el Worker y en el navegador. Se aceptan números en cadena cuando coinciden con un patrón numérico finito estricto; también se aceptan cadenas de array codificadas en JSON para clientes que solo envían campos de texto. En caso de éxito la respuesta hace eco de f y g redondeados, fija composition a la lista completa de coeficientes expandidos (constante primero), degree_f, degree_g y degree a los grados formales de los factores y del compuesto, f_str, g_str y composition_str a polinomios legibles compactos con signos sensatos y coeficientes unitarios omitidos, formula a una breve descripción en inglés de la composición de Horner, message a un resumen de grado en una línea, y steps a un array ordenado de líneas de sustitución que puede afirmar en pruebas. La validación fallida—campos ausentes, arrays vacíos, no-arrays, entradas no finitas, listas más largas que el máximo publicado, valores fuera de límites absolutos, resultados sobredimensionados o intermedios no finitos—devuelve invalid_input y nunca se cobra. El precio es un $0.002 fijo por petición exitosa con ítem unitario.
Consejos prácticos, límites y búsquedas relacionadas
Prefiera enviar arrays JSON genuinos en lugar de cadenas preformateadas cuando controle el cliente. Empareje esos éxitos con un f vacío o un g vacío para documentar la ruta dura invalid_input. Las tareas fallidas que devuelven invalid_input no consumen saldo prepago, lo que mantiene baratos los scripts exploratorios cuando los alumnos envían deliberadamente listas vacías.
Casos de integración
Pruebas unitarias para bibliotecas de polinomios de alumnos
Genere casos de composición conocidos como correctos más rechazos deliberados de lista vacía para valores esperados de kata de código y fixtures de integración continua.