Multiplicación de polinomios
Desarrolle un producto de polinomios sin errores: (1 + 2x) por (3 + 4x) es 3 + 10x + 8x², y el grado del producto, 2, es la suma de los grados. 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 multiplicación de polinomios convierte dos listas de coeficientes en el producto expandido de los polinomios correspondientes. Introduzca p y q como arrays de números con el término constante primero—así [1, 2] significa 1 + 2x y [3, 4] significa 3 + 4x—y la herramienta devuelve los coeficientes del producto, cadenas de polinomio legibles, grados de ambos factores y del producto, y notas de convolución paso a paso. Comprobaciones de deberes, preparación de exámenes, valores esperados de kata de código y demos de procesamiento de señales necesitan la misma convolución discreta sin abrir un sistema de álgebra computacional.
Qué significan las listas de coeficientes y cómo se forma el producto
Un polinomio univariado queda completamente determinado por su secuencia de coeficientes reales una vez fijada la convención de orden. 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 segunda entrada usa la misma convención.
Esa suma es exactamente la convolución discreta de las dos secuencias, y su longitud es siempre len(p) más len(q) menos uno antes de eliminar ceros finales para la visualización. El grado formal es el índice más alto cuyo valor absoluto supera un épsilon diminuto, de modo que una lista que termina con polvo numérico sigue informando el grado matemático correcto. El polinomio cero—todo coeficiente cero tras el redondeo—se permite como factor o como producto, y su grado se informa como menos uno por la convención algebraica habitual.
Consejos prácticos, límites y búsquedas relacionadas
Mantenga las magnitudes de coeficientes dentro del rango absoluto publicado para que los productos por pares no desborden a un término de convolución no finito que el solucionador deba rechazar. Comprobaciones clásicas de aula incluyen (1 + x) por (1 + x) igual a 1 + 2x + x al cuadrado, (2 + 3x) por (4 − x) igual a 8 + 10x − 3x al cuadrado, y una constante por cualquier polinomio escala cada coeficiente.
Este aterrizaje apunta a personas que buscan una calculadora de multiplicación de polinomios, multiplicar dos polinomios por coeficientes o expandir un producto de polinomios en línea; no es un multiplicador multivariado, ni un factorizador, ni un buscador de raíces. Prefiera esta capacidad cuando ya tenga ambos vectores de coeficientes y solo necesite el producto expandido; si su fuente es una expresión escrita, analice primero los coeficientes.
Las comprobaciones de ida y vuelta son fáciles: recalcule a mano algunas entradas product[k] desde la fórmula de convolución y confirme que coinciden con el array product publicado dentro del mismo redondeo a doce decimales.
Qué puede hacer con ella
Comprobaciones de deberes al expandir productos
Los estudiantes introducen dos listas de coeficientes de problemas de libro y comparan productos expandidos a mano, grados y cadenas legibles con un resultado determinista antes de entregar.
Demos de señal y control con convolución FIR
Las tuberías tratan respuestas al impulso FIR cortas como polinomios y las multiplican para cascada de filtros, usando el mismo producto de coeficientes sin dependencia de un CAS.
Preguntas frecuentes
¿Cómo se ordenan los coeficientes?
Término constante primero: [a0, a1, a2] significa a0 + a1·x + a2·x². El producto usa el mismo orden de bajo a alto.
¿Qué ocurre si alguna lista está vacía?
Un array vacío es dato faltante, no el polinomio cero.
¿El producto elimina ceros finales?
El array product conserva la longitud completa de convolución (len(p)+len(q)−1). El grado formal ignora cercanos a cero finales para el campo degree y la cadena de impresión.
¿Puedo multiplicar más de dos polinomios?
No en una sola llamada. Multiplique por pares: alimente el producto del primer par como p para el siguiente factor.
¿La calculadora de multiplicación de polinomios es gratuita?
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-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)Ejemplo de solicitud
{
"p": [
1,
2
],
"q": [
3,
4
]
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_multiply",
"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 | 256 |
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é significan las listas de coeficientes y cómo se forma el producto
El producto algebraico de dos de esos polinomios es de nuevo un polinomio cuyo coeficiente en el grado k es la suma sobre i de a_i por b_{k−i} para cada par de índices que permanece dentro de ambos arrays. Lo que no se permite es un array de coeficientes vacío: vacío no es un polinomio cero; es dato faltante, y la API devuelve invalid_input para que scripts de deberes y tuberías de calificación fallen ruidosamente en lugar de tratar el silencio como cero.
Cómo llamar a la API y qué vuelve
Envíe un cuerpo JSON con dos arrays no vacíos obligatorios de números finitos: p (alias poly1, a, left) y q (alias poly2, b, right). Cada array puede tener como máximo doscientos cincuenta y seis 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 p y q redondeados, fija product a la lista completa de coeficientes de convolución (constante primero), degree_p, degree_q y degree a los grados formales de los factores y del producto, p_str, q_str y product_str a polinomios legibles compactos con signos sensatos y coeficientes unitarios omitidos, formula a una breve descripción en inglés de la convolución de coeficientes, 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 o productos no finitos—devuelve invalid_input y nunca se cobra. El precio es un $0.002 fijo por petición exitosa con ítem unitario y precio unitario marginal cero.
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 p vacío o un q 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 convolució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.