Simplifier une expression logarithmique
Saisissez log(100x²/y) + log(y) et obtenez 2 + 2 log(x) : les logarithmes sont séparés par les règles usuelles, le logarithme de 100 devient exactement 2 et les termes log(y) opposés s'annulent. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Expression
- log(100*x^2/y) + log(y)
- Simplifié
- 2 + 2*log(x)
- Constante exacte
- 2
- Termes
- 2
Ce simplificateur transforme une expression logarithmique compacte en résultat réduit et vérifiable. Les produits, quotients et puissances entières sont séparés selon les lois usuelles. Les parties numériques sont évaluées lorsqu'elles sont des puissances entières exactes de la base, tandis que les parties symboliques restent sous forme exacte. Les logarithmes semblables sont regroupés, les termes opposés s'annulent et la réponse fournit quelques étapes. L'algorithme est déterministe et ne dépend ni du réseau, ni du hasard, ni de l'heure.
Ce que signifie simplifier une expression logarithmique
Simplifier une expression logarithmique consiste à la réécrire sous une forme équivalente plus courte, sans remplacer une structure exacte utile par une approximation décimale. Ce calculateur applique la règle du produit, qui transforme le logarithme d'un produit en somme ; la règle du quotient, qui transforme le logarithme d'un quotient en différence ; et la règle de la puissance, qui place un exposant entier devant le logarithme. Ainsi, log(100*x^2/y) devient 2 + 2*log(x) - log(y), car le logarithme décimal de 100 vaut exactement deux.
Si l'expression contient aussi +log(y), ces termes symboliques opposés s'annulent. Dans les nombres réels, les arguments numériques doivent être positifs. Les variables sont considérées comme des quantités symboliques positives, conformément à l'hypothèse usuelle des exercices d'algèbre.
Le résultat conserve donc une forme exacte et isole toute constante démontrable à partir d'une puissance entière de la base, sans convertir log(3) en valeur décimale arrondie.
Saisie des expressions et lecture de la réponse
Fournissez une expression textuelle. Chaque terme de premier niveau doit être un logarithme, éventuellement précédé d'un coefficient numérique et d'un astérisque. Reliez les logarithmes par des signes plus ou moins.
Dans un argument, utilisez un astérisque pour la multiplication, une barre oblique pour la division et un accent circonflexe suivi d'un entier pour une puissance. Un nom de variable simple peut contenir des lettres, des chiffres après la première lettre et des traits de soulignement. Les parenthèses délimitent l'argument ; les sommes imbriquées et fonctions arbitraires dépassent cette grammaire ciblée.
L'évaluation exacte reste volontairement prudente : un facteur positif ne devient une constante que si son logarithme est entier selon une tolérance stricte.
Contrôles utiles, limites et méthodes de travail
Pour vérifier un calcul manuel, prévoyez d'abord l'effet de chaque règle. Comptez les facteurs d'un produit comme des termes logarithmiques positifs, ceux du dénominateur comme des termes négatifs, puis multipliez chaque signe par l'exposant entier du facteur. Repérez ensuite les facteurs numériques qui sont des puissances reconnaissables de la base.
L'annulation constitue un autre contrôle : log(x) - log(x) doit disparaître et deux exemplaires de log(x) doivent donner 2*log(x). Pour le logarithme naturel, les puissances du facteur littéral e sont évaluées exactement ; ln(e^3*x) devient donc 3 + ln(x). Cet outil travaille dans les nombres réels et suppose les variables symboliques positives ; il ne produit pas une condition de domaine complète.
Il ne distribue pas non plus un logarithme sur une somme, car aucune règle de ce type n'existe pour log(a+b). Les sommes imbriquées, radicaux, bases symboliques, exposants fractionnaires, équations et valeurs complexes nécessitent un système de calcul formel plus général. La grammaire stricte garantit une interprétation prévisible.
Pour les traitements par lots, utilisez des multiplications explicites et des parenthèses équilibrées, dans la limite de mille caractères et soixante-quatre termes principaux.
Cas d’usage
Vérifier des exercices d'algèbre
Comparez l'application manuelle des lois logarithmiques à une expression réduite déterministe et à des étapes concises.
Créer des corrigés de fiches
Réduisez des exercices cohérents en base dix, logarithme naturel ou base numérique à des réponses exactes et stables.
Questions fréquentes
Quelles règles logarithmiques sont appliquées ?
Le calculateur applique les règles du produit, du quotient et de la puissance entière, puis évalue les parties exactes et regroupe les termes semblables.
Pourquoi log(3) reste-t-il inchangé ?
Seules les puissances entières dont l'exactitude est démontrée sont évaluées. L'outil ne remplace pas une expression exacte par une décimale arrondie.
Peut-il simplifier log(x+y) ?
Non. Un logarithme ne se distribue pas sur une somme ; cette grammaire accepte les produits, quotients et puissances entières dans les arguments.
Pourquoi le logarithme de 100 devient-il 2 ?
Parce que 100 est dix au carré et qu'un log sans base utilise la base dix. Les nombres qui sont des puissances entières de la base sont évalués exactement, sans être remplacés par un décimal arrondi.
ln(x) et log(x) sont-ils regroupés ?
Non. Seuls les termes ayant la même base et le même argument sont regroupés : ln(x) et log(x) restent donc séparés, alors que deux termes log(x) s'additionnent.
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/algebra/log-simplify \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"expression":"log(100*x^2/y) + log(y)"}'const res = await fetch("https://api.kit.forhosting.com/algebra/log-simplify", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"expression": "log(100*x^2/y) + log(y)"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/log-simplify",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"expression": "log(100*x^2/y) + log(y)"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/log-simplify", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"expression":"log(100*x^2/y) + log(y)"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"expression":"log(100*x^2/y) + log(y)"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/log-simplify", 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
{
"expression": "log(100*x^2/y) + log(y)"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.log_simplify",
"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_chars | 1000 |
max_terms | 64 |
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
Saisissez log ou log10 pour un logarithme décimal, ln pour un logarithme naturel, ou une base numérique avec une notation telle que log_2.
Ce que signifie simplifier une expression logarithmique
Les termes ne sont regroupés que si leur notation de base et leur argument correspondent : ln(x) n'est donc jamais combiné à tort avec log(x). log seul utilise la base dix, log10 indique explicitement cette même base, ln utilise la base naturelle, et log_2 ou tout autre indice numérique positif choisit cette base.
Saisie des expressions et lecture de la réponse
Les formes valides comprennent log(100*x^2/y), 3*ln(x), log10(0.01) et log_2(8*a/b^2). Une réponse valide répète l'expression, fournit la forme réduite dans simplified, indique exact_constant séparément, compte les éléments restants et énumère les étapes. Ainsi, log(1000), log_2(8) et ln(e^4) deviennent respectivement 3, 3 et 4, tandis que log(7) reste inchangé. Chaque élément API réussi coûte $0.002. Une syntaxe invalide, des parenthèses déséquilibrées, une base interdite ou un argument non positif renvoient invalid_input plutôt qu'un résultat supposé.
Contrôles utiles, limites et méthodes de travail
À la réception du résultat, comparez exact_constant et les logarithmes restants à vos prévisions.
Cas d'intégration
Valider un logiciel éducatif
Employez des résultats JSON exacts et des entrées invalides explicites dans les tests automatisés de cours sur les logarithmes.
Questions techniques
Quelle base la notation log utilise-t-elle ?
log et log10 utilisent la base dix. Choisissez ln pour le logarithme naturel ou log_2 pour une autre base numérique positive.
Quel est le prix d'une requête API ?
Le calculateur web est gratuit. Une requête API réussie coûte $0.002 ; une entrée incorrecte renvoie invalid_input.