ForHosting KIT · Mathématiques

Polynôme à partir des racines

Transformez des racines connues en polynôme sous forme développée : les racines 1, 2 et 3 donnent (x − 1)(x − 2)(x − 3), soit x³ − 6x² + 11x − 6. Répétez une racine pour en faire une racine double. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Un calculateur de polynôme à partir des racines transforme une liste de zéros réels en le vecteur de coefficients développés d'un polynôme univarié. Saisissez les racines r1 à rn et un coefficient dominant a optionnel non nul (par défaut un, polynôme unitaire). La multiplicité s'encode en répétant une racine dans la liste.

Des racines aux coefficients : facteurs linéaires et développement

Tout polynôme univarié non nul sur les réels se factorise (à une échelle dominante près) en facteurs linéaires pour ses racines réelles et en quadratiques irréductibles pour les paires conjuguées complexes. Multiplier par un coefficient dominant a non nul met à l'échelle uniformément chaque coefficient développé et fixe le coefficient de plus haut degré égal à a lorsque le degré formel vaut n.

La multiplicité n'est pas un champ séparé : listez la même racine deux fois pour une racine double, trois fois pour une triple, et ainsi de suite, comme les manuels écrivent (x moins deux) au carré sous la forme (x moins deux) fois (x moins deux). Le développement avance par multiplications successives. Partez de la constante un, remplacez la liste courante de coefficients par son produit avec le facteur linéaire suivant (x moins ri)—une convolution décalage-et-soustraction de longueur un—puis, après consommation de toutes les racines, mettez à l'échelle par a.

La suite résultante est stockée terme constant en tête pour s'aligner sur les outils frères d'addition, de multiplication et de division de polynômes. Le degré formel est l'indice le plus élevé dont la valeur absolue dépasse un epsilon minuscule, de sorte que la poussière flottante n'enfle pas le degré rapporté.

Contrôles classiques : racines un et deux avec dominant un donnent x au carré moins trois x plus deux ; racines un et moins un avec dominant deux donnent deux x au carré moins deux ; une seule racine zéro donne le monôme x.

Classe, automatisation et différence avec les chercheurs de racines

L'intention de recherche d'un calculateur de polynôme à partir des racines est l'inverse d'un chercheur de racines de polynômes : apprenants et scripts connaissent déjà les zéros et ont besoin de la forme standard développée, pas l'inverse. Les plateformes de tutorat utilisent ce point de terminaison pour que les élèves vérifient les développements à la main de (x moins trois)(x plus un) face à une liste de coefficients déterministe.

Les générateurs d'examens échantillonnent des racines entières, développent une fois et stockent à la fois l'énoncé factorisé et la clé de coefficients. Les tests unitaires de bibliothèques polynomiales étudiantes ont besoin de produits connus de facteurs linéaires plus des rejets délibérés de liste vide. Les démos de contrôle et de signal qui placent pôles ou zéros à des emplacements de conception développent le polynôme caractéristique de la même façon sans importer un CAS complet.

Préférez cette capacité lorsque votre source de vérité est une liste de racines ; préférez le frère chercheur de racines lorsque vous avez déjà le vecteur de coefficients. Gardez magnitudes et nombres de racines dans les limites publiées pour que les multiplications successives ne débordent pas. Les contrôles aller-retour sont aisés lorsque toutes les racines sont réelles et listées avec multiplicité : développez ici, alimentez les coefficients d'un chercheur de racines et comparez les racines récupérées avec la même politique d'arrondi.

La page vise qui cherche polynôme à partir des racines, construire un polynôme depuis des zéros, développer des facteurs linéaires en coefficients et polynôme unitaire depuis des racines en ligne.

Cas d’usage

Contrôle de devoirs pour développer des facteurs linéaires

Les élèves saisissent des racines connues et un coefficient dominant optionnel, puis comparent les coefficients développés à la main et la chaîne en forme standard à un résultat déterministe avant de rendre.

Clés d'examen et notation automatique LMS

Générez des polynômes unitaires ou mis à l'échelle à partir de listes de racines échantillonnées pour que les correcteurs disposent de clés de coefficients stables sans logiciel symbolique.

Questions fréquentes

Dans quel ordre sont les coefficients ?

Terme constant en tête : [a0, a1, a2] signifie a0 + a1·x + a2·x².

Comment encoder une racine répétée ?

Listez la même valeur plusieurs fois. Une racine double en 2 est roots [2, 2], qui développe (x−2)².

Comment utiliser un coefficient dominant différent de 1 ?

Indiquez-le comme coefficient dominant : tous les coefficients développés sont multipliés par lui. Avec les racines 1 et −1 et un coefficient dominant de 2, on obtient 2x² − 2 au lieu de x² − 1.

Quel polynôme donne une seule racine égale à 0 ?

Le monôme x, de degré 1. Chaque racine apporte un facteur (x moins la racine), donc la racine 0 apporte simplement x.

Combien de racines puis-je saisir ?

Jusqu'à soixante-quatre racines réelles, chacune un nombre fini. Le degré du polynôme obtenu est égal au nombre de racines, répétitions comprises.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/algebra/polynomial-from-roots

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/algebra/polynomial-from-roots \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"roots":[1,2,3]}'

const res = await fetch("https://api.kit.forhosting.com/algebra/polynomial-from-roots", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "roots": [
      1,
      2,
      3
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/algebra/polynomial-from-roots",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "roots": [
        1,
        2,
        3
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/polynomial-from-roots", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"roots":[1,2,3]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"roots":[1,2,3]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/polynomial-from-roots", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "roots": [
    1,
    2,
    3
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "algebra.polynomial_from_roots",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Les listes de racines vides et un coefficient dominant nul échouent avec invalid_input au lieu d'inventer une constante silencieuse ou un degré effondré. Le chemin est une arithmétique pure et déterministe—sans réseau, sans graines aléatoires, sans horloge—de sorte que l'exécuteur gratuit du navigateur et l'API prépayée s'accordent après l'arrondi fixe à douze décimales à chaque appel.

Contrat d'entrée, champs de réponse et erreurs

Envoyez un corps JSON avec roots obligatoire, un tableau non vide d'au plus soixante-quatre nombres finis, et leading optionnel (alias a, leading_coefficient, scale) valant un par défaut. Roots accepte aussi les alias zeros, root_list et r. Chaque racine peut arriver comme nombre JSON ou comme chaîne numérique stricte ; une chaîne de tableau encodée en JSON est acceptée pour les clients qui n'envoient que des champs texte. Les valeurs absolues doivent rester dans un billion pour que les produits intermédiaires restent finis en double précision IEEE sur le Worker et dans le navigateur. En succès le corps renvoie roots et leading arrondis, fixe coefficients à la liste développée constante en tête, coefficients_high_to_low aux mêmes valeurs inversées pour les affichages puissance haute d'abord, degree et root_count en entiers, factors_str en produit compact de facteurs linéaires avec l'échelle dominante préfixée lorsqu'elle n'est pas un, polynomial en forme développée lisible avec signes raisonnables et coefficients unitaires omis, formula en courte identité, message en résumé de degré d'une ligne, et steps en lignes de substitution ordonnées pour goldens et captures de cours. Une validation échouée—roots manquant, tableaux vides, non-tableaux, entrées non finies, listes plus longues que le maximum publié, valeurs hors limites absolues, leading nul ou coefficients intermédiaires non finis—renvoie invalid_input et n'est jamais facturée. Le prix est un $0.002 fixe par requête réussie avec unité item.

Classe, automatisation et différence avec les chercheurs de racines

Les tâches en échec invalid_input ne consomment pas le solde prépayé, ce qui maintient bon marché les scripts exploratoires lorsque l'on envoie à dessein des listes vides ou un coefficient dominant nul.

Cas d'intégration

Tests unitaires de bibliothèques polynomiales

Produisez des développements connus de ∏(x−ri) plus des rejets de liste vide et de leading nul pour fixtures de kata de code et intégration continue.

Questions techniques

Comment construire un polynôme à partir d'une liste de racines ?

Envoyez roots comme un tableau non vide de nombres finis et leading optionnel (défaut 1). L'API développe leading·∏(x−ri) et renvoie les coefficients constante en tête plus une chaîne polynomiale lisible.

Que se passe-t-il si leading est nul ou roots vide ?

Les deux sont invalid_input. Un coefficient dominant nul effondrerait le degré ; une liste de racines vide est une donnée de facteurs manquante, pas un mode constant-seul documenté.

Combien coûte le calculateur de polynôme à partir des racines ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; l'entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement

Des racines aux coefficients : facteurs linéaires et développement

Classe, automatisation et différence avec les chercheurs de racines

Cas d’usage

Contrôle de devoirs pour développer des facteurs linéaires

Clés d'examen et notation automatique LMS

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Erreurs

Notes techniques

Contrat d'entrée, champs de réponse et erreurs

Classe, automatisation et différence avec les chercheurs de racines

Cas d'intégration

Tests unitaires de bibliothèques polynomiales

Questions techniques

merci