Développer un logarithme : produit, quotient et puissance
Développer un logarithme consiste à prendre un logarithme unique dont l'argument est formé de multiplications, de divisions et de puissances — par exemple le logarithme en base 2 de x·y/z — et à le réécrire sous forme d'une somme de logarithmes plus simples : log₂(x) + log₂(y) − log₂(z).
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Cette API effectue cette réécriture pour vous. Vous envoyez la base et la liste des facteurs avec leurs opérations, et vous recevez en retour l'expression développée, un terme par facteur, avec les signes et les coefficients corrects. Les arguments numériques sont validés : un logarithme n'est défini que pour des arguments strictement positifs, donc tout facteur nul ou négatif est rejeté avec une erreur claire au lieu de produire une expression dépourvue de sens.
Ce que signifie développer un logarithme
Les trois lois des logarithmes transforment la structure à l'intérieur de l'argument en structure à l'extérieur. La règle du produit dit que log_b(x·y) est égal à log_b(x) plus log_b(y) : une multiplication à l'intérieur devient une addition à l'extérieur. La règle du quotient dit que log_b(x/y) est égal à log_b(x) moins log_b(y) : une division à l'intérieur devient une soustraction à l'extérieur. La règle de la puissance dit que log_b(x^n) est égal à n fois log_b(x) : un exposant à l'intérieur glisse devant comme coefficient. Développer un logarithme, c'est appliquer ces lois de gauche à droite jusqu'à ce que plus rien, à l'intérieur d'aucun logarithme, ne puisse être décomposé davantage. Les élèves rencontrent cette opération lorsqu'ils simplifient des expressions avant de dériver, lorsqu'ils résolvent des équations exponentielles et lorsqu'ils linéarisent des données pour un graphique log-log. L'opération est purement mécanique dès lors que vous identifiez chaque facteur et la manière dont il entre dans l'argument, et c'est exactement pourquoi elle convient à une API : vous décrivez l'expression comme une base accompagnée d'une liste d'opérations et de facteurs, et le développement vous revient sous la forme d'une chaîne prête à l'emploi, chaque terme étant explicité avec son signe, son coefficient et son argument.
Comment décrire votre expression à l'API
L'entrée comporte deux parties. La base est la base du logarithme : tout nombre positif autre que 1, donc 2, 10 et e conviennent tous, tandis que 1, 0 et les nombres négatifs sont rejetés car aucun logarithme réel n'admet une telle base. Le tableau de termes énumère les facteurs de l'argument dans l'ordre. Chaque terme désigne une opération — multiplication, division ou puissance — et un argument. Un terme de multiplication apporte son logarithme avec un signe plus, un terme de division avec un signe moins, et un terme de puissance avec son exposant extrait comme coefficient placé devant. Ainsi, le logarithme en base 2 de x·y/z³ correspond à trois termes : multiplication par x, multiplication par y et puissance de z d'exposant 3, ce qui se développe en log₂(x) + log₂(y) − 3·log₂(z). Les arguments peuvent être symboliques, comme x ou price, lorsque vous voulez la forme algébrique, ou numériques, comme 8, lorsque vous voulez une vérification concrète. Les arguments numériques doivent être positifs ; les arguments symboliques sont conservés tels quels, car leur signe dépend des valeurs que vous leur attribuerez ensuite. Un exposant négatif sur un terme de puissance inverse simplement le signe du terme, puisque x à la puissance moins n revient à diviser par x à la puissance n.
Pourquoi la validation du domaine est importante
Un logarithme réel n'est défini que pour des arguments strictement positifs. Le logarithme de zéro diverge vers moins l'infini et le logarithme d'un nombre négatif n'est pas du tout un nombre réel, de sorte qu'un développement fondé sur un facteur non positif serait un bruit symbolique qui se briserait silencieusement dès que quelqu'un l'évaluerait. Ce point d'accès refuse de produire ce bruit : lorsqu'un argument numérique est nul ou négatif, l'appel échoue avec une erreur d'entrée invalide nommant le terme fautif, et l'appel ne vous est pas facturé. La même rigueur s'applique à la base, qui doit être positive et différente de 1, et aux exposants, qui doivent être des nombres finis — un exposant de zéro est rejeté car le terme contribuerait alors le logarithme de 1, c'est-à-dire zéro, ce qui est presque toujours une erreur dans l'entrée. Le résultat est déterministe : la même requête renvoie toujours la même chaîne, octet pour octet, ce qui rend ce point d'accès sûr à utiliser dans des feuilles d'exercices générées, des correcteurs automatisés et des vérifications CI qui comparent les sorties littéralement. Il s'exécute sur notre réseau de périphérie sans rien stocker, et le même algorithme tourne gratuitement dans le navigateur sur cette page, de sorte que vous ne payez $0.002 par appel que lorsque vous l'automatisez.
Cas d’usage
Générer des exercices d'algèbre corrigés
Fournissez une base et une liste de facteurs, puis intégrez la forme développée directement dans des feuilles d'exercices, des quiz ou des solutions pas à pas.
Vérifier automatiquement les réponses des devoirs
Comparez l'expression développée par un élève à la chaîne canonique renvoyée par l'API pour la même base et les mêmes termes.
Simplifier avant de dériver
Développez le logarithme d'un produit ou d'un quotient en une somme afin que chaque terme se dérive séparément, une étape classique des flux de calcul différentiel.
Questions fréquentes
Combien cela coûte-t-il ?
$0.002 par requête. Le même algorithme s'exécute aussi gratuitement dans votre navigateur sur cette page.
Quelles bases sont acceptées ?
Tout nombre positif sauf 1 : 2, 10, e ou toute autre base valide. Les bases égales à 1, 0 ou à un nombre négatif sont rejetées.
Les facteurs peuvent-ils être des variables plutôt que des nombres ?
Oui. Un argument peut être symbolique (x, price, velocity) ou numérique. Les arguments numériques doivent être positifs ; les arguments symboliques sont conservés tels qu'ils sont écrits.
Que se passe-t-il si un argument est nul ou négatif ?
L'appel échoue avec une erreur d'entrée invalide nommant le terme concerné, car un logarithme réel n'y est pas défini. Les appels rejetés ne vous sont pas facturés.
Comment les puissances se développent-elles ?
Un terme de puissance d'exposant n apporte n fois le logarithme de son argument ; un exposant négatif inverse le signe du terme. Un exposant de 0 est rejeté.
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/expanding-logarithms \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"base":2,"terms":[{"operation":"multiply","argument":"x"},{"operation":"multiply","argument":"y"},{"operation":"divide","argument":"z"}]}'const res = await fetch("https://api.kit.forhosting.com/math/expanding-logarithms", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"base": 2,
"terms": [
{
"operation": "multiply",
"argument": "x"
},
{
"operation": "multiply",
"argument": "y"
},
{
"operation": "divide",
"argument": "z"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/expanding-logarithms",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"base": 2,
"terms": [
{
"operation": "multiply",
"argument": "x"
},
{
"operation": "multiply",
"argument": "y"
},
{
"operation": "divide",
"argument": "z"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/expanding-logarithms", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"base":2,"terms":[{"operation":"multiply","argument":"x"},{"operation":"multiply","argument":"y"},{"operation":"divide","argument":"z"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"base":2,"terms":[{"operation":"multiply","argument":"x"},{"operation":"multiply","argument":"y"},{"operation":"divide","argument":"z"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/expanding-logarithms", 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
{
"base": 2,
"terms": [
{
"operation": "multiply",
"argument": "x"
},
{
"operation": "multiply",
"argument": "y"
},
{
"operation": "divide",
"argument": "z"
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.expanding_logarithms",
"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.
Limites
max_terms | 32 |
max_abs | 1000000000000 |
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. |