Composizione di polinomi
Sostituisca un polinomio dentro un altro e ottenga il risultato sviluppato: con f(x) = x² e g(x) = 1 + x, f(g(x)) è 1 + 2x + x², di grado 2. Ogni passaggio è mostrato. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Funziona nel tuo browser: gratis, senza registrazione, i file non escono dal tuo dispositivo.
Una calcolatrice di composizione di polinomi costruisce il composto espanso f(g(x)) a partire da due liste di coefficienti. Inserisca il polinomio esterno f e quello interno g con il termine costante per primo—così [1, 2, 1] significa 1 + 2x + x al quadrato e [0, 1] significa x—e lo strumento restituisce i coefficienti della composizione dopo aver sostituito g in f, combinato i termini simili, stringhe di polinomio leggibili, gradi formali di f, g e del composto, più note di Horner passo per passo. Controlli dei compiti, preparazione agli esami, valori attesi di kata di codice e demo di cambio di variabile richiedono la stessa espansione per sostituzione senza aprire un sistema di algebra computazionale.
Cosa significa f(g(x)) e come sono ordinati i coefficienti
La composizione di funzioni per i polinomi significa sostituzione: se f associa a un valore u l'espressione a0 più a1 volte u più a2 volte u al quadrato e potenze superiori, e g associa a x l'espressione b0 più b1 volte x e potenze superiori, allora f di g di x è il polinomio ottenuto sostituendo ogni occorrenza di u in f con l'espressione completa di g di x, espandendo i prodotti delle potenze di g e raccogliendo le potenze simili di x.
Il risultato è di nuovo un polinomio univariato il cui grado formale è il prodotto dei gradi formali di f e g quando entrambi sono positivi, oppure zero quando f è una costante non nulla, oppure meno uno per il polinomio zero. Questo strumento usa la convenzione termine-costante-per-primo che domina la programmazione e le librerie numeriche: l'array [a0, a1, a2, …, am] rappresenta a0 più a1 volte x più a2 volte x al quadrato, fino ad am volte x alla m.
La stessa convenzione si applica a g e all'array di composizione restituito. L'espansione algebrica avviene con la forma annidata di Horner a0 più g volte (a1 più g volte (a2 più …)), così ogni passo moltiplica il polinomio corrente per g e aggiunge il coefficiente esterno successivo—equivalente a espandere f di g e combinare i termini simili, ma con meno moltiplicazioni intermedie. Una lista di coefficienti tutta zero è valida e rappresenta il polinomio zero con grado meno uno.
Consigli pratici, limiti e ricerche correlate
Mantenga le magnitudini dei coefficienti entro l'intervallo assoluto pubblicato e preferisca gradi modesti affinché il prodotto dei gradi resti ben al di sotto del tetto di lunghezza del risultato. Controlli classici in aula includono f uguale a x al quadrato con g uguale a uno più x che dà uno più due x più x al quadrato, f uguale a due più tre x con g uguale a uno meno x che dà cinque meno tre x, e comporre con l'identità g uguale a x che lascia f invariato.
Questa landing punta a chi cerca una calcolatrice di composizione di polinomi, comporre due polinomi online, espandere f di g di x o sostituire un polinomio in un altro; non è un compositore multivariato, né un fattorizzatore, né un cercatore di radici. Preferisca questa capacità quando ha già entrambi i vettori di coefficienti e le serve solo il composto espanso; se la fonte è un'espressione scritta, analizzi prima i coefficienti. Quando le serve solo il prodotto di due polinomi senza sostituzione, usi invece uno strumento di moltiplicazione dedicato.
I controlli andata e ritorno sono semplici: ricalcoli a mano alcuni coefficienti di composizione da Horner o espandendo potenze di g e confermi che coincidono con l'array composition pubblicato entro lo stesso arrotondamento a dodici decimali.
Casi d'uso
Controlli dei compiti per espandere f(g(x))
Gli studenti inseriscono liste di coefficienti esterno e interno da problemi di composizione del libro e confrontano composti espansi a mano, gradi e stringhe leggibili con un risultato deterministico prima di consegnare.
Demo di cambio di variabile nella preparazione al calcolo
Le pipeline sostituiscono un cambio di variabile lineare o quadratico in un polinomio esterno di grado superiore per costruire esempi d'esame senza dipendenza da un sistema di algebra computazionale.
Domande frequenti
Come sono ordinati i coefficienti?
Termine costante per primo: [a0, a1, a2] significa a0 + a1·x + a2·x². La composizione usa lo stesso ordine dal basso verso l'alto.
Il risultato è f(g(x)) o g(f(x))?
Sempre f(g(x)): g viene sostituito in f. Scambi i due array se le serve l'altro ordine.
Cosa succede se una delle liste è vuota?
Un array vuoto è dato mancante, non il polinomio zero.
Qual è il grado della composizione?
Quando entrambi i gradi formali sono positivi, deg(f∘g) è uguale a deg(f)·deg(g). Costanti e polinomio zero seguono le usuali regole algebriche.
La calcolatrice di composizione di polinomi è gratis?
Lo strumento del browser è gratuito e gira in locale.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"f": [
1,
2,
1
],
"g": [
0,
1
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.polynomial_composition",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_coeffs | 64 |
max_result_coeffs | 1025 |
max_abs | 1000000000000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Le liste vuote vengono rifiutate con un errore invalid_input chiaro invece di inventare un polinomio zero per silenzio. Il percorso è aritmetica puramente deterministica—senza rete, senza semi casuali, senza dipendenza dall'orologio—così l'esecutore gratuito del browser e l'API prepagata restituiscono lo stesso JSON dopo un arrotondamento decimale fisso a ogni chiamata.
Cosa significa f(g(x)) e come sono ordinati i coefficienti
Gli array di coefficienti vuoti non sono ammessi: vuoto è dato mancante, non il polinomio zero, e l'API restituisce invalid_input affinché script di compiti e pipeline di valutazione falliscano in modo rumoroso.
Come chiamare l'API e cosa restituisce
Il composto espanso può contenere al massimo milleventicinque coefficienti; le composizioni il cui prodotto dei gradi supererebbe quel limite vengono rifiutate prima dell'inizio del lavoro. Invii un corpo JSON con due array non vuoti obbligatori di numeri finiti: f (alias outer, p, poly_f) per il polinomio esterno e g (alias inner, q, poly_g) per il polinomio interno sostituito in f. Ogni array può contenere al massimo sessantaquattro coefficienti, e ogni valore assoluto di coefficiente deve restare entro un bilione affinché i prodotti intermedi restino finiti in doppia precisione IEEE sul Worker e nel browser. I numeri in stringa sono accettati quando corrispondono a un pattern numerico finito rigoroso; anche le stringhe di array codificate in JSON sono accettate per client che inviano solo campi di testo. In caso di successo la risposta riecheggia f e g arrotondati, imposta composition sull'elenco completo dei coefficienti espansi (costante per primo), degree_f, degree_g e degree sui gradi formali dei fattori e del composto, f_str, g_str e composition_str su polinomi leggibili compatti con segni sensati e coefficienti unitari omessi, formula su una breve descrizione in inglese della composizione di Horner, message su un riepilogo di grado in una riga, e steps su un array ordinato di righe di sostituzione che Lei può asserire nei test. La validazione fallita—campi assenti, array vuoti, non-array, voci non finite, liste più lunghe del massimo pubblicato, valori fuori dai limiti assoluti, risultati oversized o intermedi non finiti—restituisce invalid_input e non viene mai addebitata. Il prezzo è un forfait $0.002 per richiesta riuscita con unità item.
Consigli pratici, limiti e ricerche correlate
Preferisca inviare veri array JSON anziché stringhe preformattate quando controlla il client. Abbini quei successi a un f vuoto o un g vuoto per documentare il percorso duro invalid_input. Le attività fallite che restituiscono invalid_input non consumano il saldo prepagato, il che mantiene economici gli script esplorativi quando gli studenti inviano di proposito liste vuote.
Casi di integrazione
Test unitari per librerie di polinomi degli studenti
Generi casi di composizione noti come corretti più rifiuti deliberati di lista vuota per valori attesi di kata di codice e fixture di integrazione continua.