Développement décimal d'une fraction
1/3 donne 0,(3) et 1/7 donne 0,(142857), avec le bloc qui se répète entre parenthèses, tandis qu'une fraction qui se termine, comme 1/8, donne un 0,125 net. Vous savez toujours si un décimal est exact. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Numérateur
- 1
- Dénominateur
- 8
- Valeur
- 0,125
- Décimal
- 0.125
Vous obtenez la valeur numérique directe, une chaîne décimale exacte construite par une véritable division longue et, lorsque le développement se répète à l'infini, le bloc répétitif clairement indiqué, de sorte que 1/3 revient sous la forme 0.(3) au lieu d'un vague 0.3333333333333333. Un dénominateur nul est rejeté avec une erreur claire, car la division par zéro n'est pas définie. Tout repose sur une arithmétique déterministe : aucun réseau, aucun aléa et aucune approximation au-delà de la valeur finale en virgule flottante.
Pourquoi un développement décimal est plus qu'une division
N'importe qui peut saisir une division dans une calculatrice et lire quelques chiffres à l'écran. Le problème est que la calculatrice décide silencieusement du nombre de chiffres à afficher, et ce qu'elle cache est souvent la partie qui compte. Un tiers n'est pas 0.3333333333 — c'est 0.3 qui se répète indéfiniment, et prendre l'affichage tronqué pour la valeur réelle introduit une erreur d'arrondi qui s'accumule à chaque étape ultérieure d'un calcul.
Ce point de terminaison effectue la division longue comme vous le feriez sur papier, en conservant chaque reste intermédiaire, et surveille ces restes pour détecter une répétition. Dès qu'un reste apparaît une seconde fois, le développement est garanti de boucler à partir de ce point, et le bloc répétitif est rapporté exactement, entre parenthèses.
Les fractions exactes comme 1/8 reviennent sous la forme d'une chaîne finie et propre, sans remplissage ni chiffres finaux parasites, de sorte que vous savez toujours si le décimal que vous tenez est exact ou l'abréviation d'un développement infini.
Comment fonctionne l'algorithme
Les signes sont traités séparément afin de diviser la magnitude avec une simple arithmétique entière. La partie entière découle d'une seule division avec arrondi inférieur ; la partie fractionnaire est ensuite produite chiffre par chiffre par la boucle classique apprise à l'école — multiplier le reste par dix, prendre le chiffre suivant, conserver le nouveau reste.
Une table associant chaque reste à la position où il est apparu la première fois détecte le cycle en temps constant, de sorte qu'une fraction comme 1/7 renvoie 0.(142857) après quelques étapes au lieu de s'égarer indéfiniment. Le développement est strictement plafonné à deux cents chiffres fractionnaires ; si aucun cycle ne s'est refermé d'ici là, la chaîne est marquée comme tronquée plutôt que présentée comme exacte. La valeur numérique directe, calculée une fois en virgule flottante, est incluse pour les appelants qui n'ont besoin que d'un nombre.
Où cela s'intègre dans une chaîne de traitement
La conversion de fraction en décimal apparaît partout où des nombres rationnels circulent entre systèmes : plateformes éducatives qui doivent afficher des réponses exactes, moteurs de tarification qui stockent les coûts unitaires sous forme de fractions et ont besoin de décimaux pour les factures, outils de mesure convertissant des fractions impériales en pouces décimaux, et suites de tests qui vérifient une bibliothèque de calcul symbolique par rapport à une référence fiable.
Dans chaque cas, le danger est le même : un arrondi invisible qui survit dans un document ou une base de données. Faire passer la conversion par ce point de terminaison vous donne une chaîne déterministe et reproductible que vous pouvez comparer, stocker et auditer, plus un signal explicite lorsque le développement réel se répète. Rien de ce que vous envoyez n'est conservé : la fraction est convertie puis supprimée, et seul le développement est renvoyé.
Cas d’usage
Afficher des réponses exactes dans un logiciel éducatif
Affichez 1/7 sous la forme 0.(142857) avec le bloc répétitif indiqué, au lieu d'un 0.142857 silencieusement arrondi qui marquerait comme fausse la bonne réponse d'un élève.
Convertir des fractions stockées pour les factures et rapports
Convertissez des coûts unitaires rationnels comme 7/12 en forme décimale en sachant exactement où le développement se répète, avant de formater les montants.
Valider une bibliothèque de calcul symbolique
Comparez la sortie décimale de votre bibliothèque à une référence déterministe de division longue dans une suite de tests, fraction par fraction.
Questions fréquentes
Combien cela coûte-t-il ?
L'exécution est aussi gratuite dans votre navigateur sur cette page.
Que se passe-t-il si le dénominateur est nul ?
Les requêtes à dénominateur nul ne sont pas facturées.
Comment les décimaux périodiques sont-ils représentés ?
Le bloc répétitif est placé entre parenthèses dans la chaîne décimale — 1/3 devient 0.(3) — et il est aussi renvoyé séparément dans le champ repeating. Les fractions exactes ne comportent pas ce champ.
La longueur du développement est-elle limitée ?
Oui : la partie fractionnaire est plafonnée à 200 chiffres. Si aucun cycle ne se referme avant, la chaîne se termine par des points de suspension et le résultat est signalé comme tronqué plutôt que présenté comme exact.
Puis-je envoyer les nombres sous forme de chaînes ?
Oui. Les chaînes numériques comme « 22 » et « 7 » sont acceptées et converties, mais elles doivent s'interpréter comme des nombres finis, sinon la requête est rejetée.
L'entrée est-elle stockée quelque part ?
Non. Le numérateur et le dénominateur sont traités en mémoire puis supprimés ; seul le développement décimal est renvoyé.
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
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/math/decimal \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"numerator":1,"denominator":8}'const res = await fetch("https://api.kit.forhosting.com/math/decimal", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"numerator": 1,
"denominator": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/decimal",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"numerator": 1,
"denominator": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/decimal", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"numerator":1,"denominator":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"numerator":1,"denominator":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/decimal", 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
{
"numerator": 1,
"denominator": 8
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.decimal",
"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
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
L'API de développement décimal prend une fraction — un numérateur et un dénominateur — et renvoie ce à quoi cette fraction ressemble sous forme de nombre décimal. Le même code que celui qui répond à l'API s'exécute gratuitement dans votre navigateur sur cette page : vous pouvez donc vérifier une fraction à la main et ne payer que lorsque vous automatisez la conversion de milliers de fractions.
Comment fonctionne l'algorithme
L'entrée est d'abord validée : les deux champs doivent être des nombres finis et le dénominateur ne doit pas être nul, car la division par zéro n'a pas de résultat défini et la requête est rejetée avec une erreur invalid_input plutôt qu'un infini trompeur.
Où cela s'intègre dans une chaîne de traitement
Cela coûte $0.002 par requête via l'API, sans supplément unitaire, et l'exécution est également gratuite dans votre navigateur sur cette page pour les vérifications ponctuelles.