Expandir y condensar logaritmos
Expanda log(x²y/z) en 2 log x + log y − log z, o reúna esa suma en un único logaritmo, con cada ley indicada paso a paso. Admite ln, logaritmo en base diez, base dos o cualquier base válida. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Corre en su navegador. Gratis y sin límite: sus datos no salen de esta página.
Una herramienta para expandir y condensar logaritmos reescribe expresiones con las tres leyes clásicas que enseña todo curso de álgebra. Expandir convierte un logaritmo de un producto, cociente o factor potenciado en una suma de logaritmos más simples; condensar hace lo inverso y empaqueta una combinación lineal de logaritmos en un solo logaritmo de producto o cociente. Usted envía un modo, una base opcional (natural, común, binaria o cualquier número válido) y una lista de argumentos positivos con potencias o coeficientes.
Leyes de producto, cociente y potencia de logaritmos
Tres identidades reescriben casi toda expresión logarítmica de aula sobre los reales positivos. La ley del producto dice que el logaritmo de un producto es la suma de los logaritmos: log de A por B es log A más log B, para cualquier base fija mayor que cero y distinta de uno. La ley del cociente dice que el logaritmo de un cociente es una diferencia: log de A entre B es log A menos log B.
La ley de la potencia dice que el logaritmo de una potencia trae el exponente delante: log de A a la n es n por log A. Combinadas, log de x al cuadrado por y entre z se expande en dos log x más log y menos log z. Condensar recorre el mismo camino al revés: una suma de coeficiente por log se convierte en un log de un producto de factores potenciados, con coeficientes negativos en el denominador.
Las bases pueden ser la base natural e escrita como ln, la común diez, la binaria dos, un log genérico sin subíndice u otra base numérica válida. Los argumentos deben ser estrictamente positivos cuando son números; los símbolos se tratan como variables de aula que representan cantidades positivas. Cero y negativos numéricos son errores de dominio, no elecciones estéticas, y esta herramienta los rechaza en lugar de devolver un valor complejo.
Los docentes usan las mismas tres leyes para ejercicios de simplificación, claves de examen y comprobaciones de álgebra computacional, de modo que una respuesta determinista de expandir o condensar con leyes nombradas es más útil que una simplificación de caja negra que oculta qué identidad se aplicó.
Consejos prácticos, límites y búsquedas relacionadas
Mantenga cada argumento numérico estrictamente positivo y cada base numérica positiva y distinta de uno para respetar el dominio del logaritmo real. Prefiera símbolos para deberes puramente algebraicos y números cuando también quiera comprobaciones de dominio sobre valores concretos. Limite cada petición a como máximo treinta y dos términos y valores absolutos de como máximo un billón para que el formateo intermedio siga legible.
Los factores de potencia cero no aportan y se omiten con un paso explícito. Esta página apunta a quien busca expandir logaritmos, condensar logs, calculadora de reglas de producto cociente potencia o leyes logarítmicas en línea; no es un evaluador numérico de cambio de base, ni un CAS simbólico completo, ni un solucionador de ecuaciones logarítmicas. Prefiera esta capacidad cuando ya tenga factores o sumandos y solo necesite la reescritura por leyes; si su fuente es una cadena libre con paréntesis anidados, parséela primero en términos.
Preguntas frecuentes
¿Qué hace el modo expand?
Expand toma un logaritmo de un producto, cociente o factores potenciados (sus terms como arg^power dentro del log) y lo reescribe como suma de coeficiente por log(arg) usando las leyes de producto, cociente y potencia.
¿Qué hace el modo condense?
Condense toma una suma de términos power·log(arg) y la reescribe como un solo logaritmo de un producto o cociente de los argumentos potenciados.
¿Qué bases se admiten?
Omita base para log genérico, use e/ln para natural, 10 para común, 2 para binario, o cualquier positivo distinto de 1. Las bases inválidas se rechazan.
¿La herramienta de expandir logaritmos es gratuita?
La herramienta del navegador es gratuita y se ejecuta en local.
¿Por qué los números dentro del logaritmo deben ser positivos?
Porque el logaritmo real solo está definido para valores positivos, así que un número igual a cero o negativo se rechaza. Las letras como x o y se tratan como cantidades positivas, como es habitual en clase.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/algebra/log-expand \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mode":"expand","terms":[{"arg":"x","power":2},{"arg":"y","power":1},{"arg":"z","power":-1}]}'const res = await fetch("https://api.kit.forhosting.com/algebra/log-expand", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mode": "expand",
"terms": [
{
"arg": "x",
"power": 2
},
{
"arg": "y",
"power": 1
},
{
"arg": "z",
"power": -1
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/log-expand",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mode": "expand",
"terms": [
{
"arg": "x",
"power": 2
},
{
"arg": "y",
"power": 1
},
{
"arg": "z",
"power": -1
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/log-expand", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mode":"expand","terms":[{"arg":"x","power":2},{"arg":"y","power":1},{"arg":"z","power":-1}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mode":"expand","terms":[{"arg":"x","power":2},{"arg":"y","power":1},{"arg":"z","power":-1}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/log-expand", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"mode": "expand",
"terms": [
{
"arg": "x",
"power": 2
},
{
"arg": "y",
"power": 1
},
{
"arg": "z",
"power": -1
}
]
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.log_expand",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_terms | 32 |
max_abs | 1000000000000 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Los argumentos numéricos nulos o negativos se rechazan con invalid_input porque salen del dominio del logaritmo real. El camino es reescritura determinista pura —sin red, sin semillas aleatorias, sin reloj— de modo que el ejecutor gratuito del navegador y la API de prepago devuelven el mismo JSON cada vez.
Cómo llamar a la API y qué devuelve
En modo expand los términos son factores dentro de un solo logaritmo: arg elevado a power multiplica dentro del log, y potencias negativas se vuelven factores de cociente. En modo condense los mismos campos significan power por log de arg en una suma que se colapsa a un log. Envíe un cuerpo JSON con mode obligatorio en expand o condense, base opcional como cadena o número, y terms obligatorio como arreglo no vacío de objetos. Cada término necesita arg, un número positivo o un símbolo simple como x o a1, y puede incluir power (alias coeff, coefficient, exp, n) por defecto uno. Se aceptan alias mode operation y action, base log_base y radix, y terms factors y parts. En éxito la respuesta incluye mode, base, base_label como ln o log_10, input_expression, result_expression, un arreglo terms con coeff, arg y cadenas de expresión por término, laws_applied listando power product quotient o identity, steps ordenados y un message breve. Validación fallida —mode o terms ausentes, terms vacío, más de treinta y dos términos, base inválida uno o no positiva, potencias no finitas o argumento numérico no positivo— devuelve invalid_input y nunca se cobra. El precio es un fijo $0.002 por petición exitosa con unidad item y precio marginal unitario cero.
Consejos prácticos, límites y búsquedas relacionadas
Al enseñar, empareje ejemplos: expanda log_10 de x al cuadrado por y entre z en dos log_10 x más log_10 y menos log_10 z; condense dos ln a más ln b en ln de a al cuadrado por b; y envíe deliberadamente arg menos tres para mostrar la ruta dura invalid_input en argumentos no positivos. Las tareas fallidas con invalid_input no consumen saldo prepago, lo que mantiene baratos los scripts exploratorios cuando los aprendices prueban el dominio. Las comprobaciones de ida y vuelta son sencillas: expandir y luego condensar con la misma base y términos debe recuperar una forma de producto equivalente, y la lista laws_applied debe mencionar cada identidad que espere para entradas de varios factores y signos mixtos.
Casos de integración
Comprobación de deberes sobre reescrituras logarítmicas
Los estudiantes introducen factores con potencias y comparan pasos manuscritos de expandir o condensar con un result_expression y lista laws_applied deterministas antes de entregar.
Pruebas unitarias para simplificadores logarítmicos de alumnos
Genere casos conocidos de expandir y condensar más rechazos deliberados de argumentos no positivos como valores esperados de kata de programación.
Claves de respuestas para docentes
Construya claves que muestren input_expression, result_expression y pasos ordenados para ejercicios de producto, cociente y potencia en ln, log_10 y log genérico.
Preguntas técnicas
¿Por qué los argumentos deben ser positivos?
Sobre los reales, log_b(x) solo está definido para x > 0 (con base b > 0, b ≠ 1). Argumentos numéricos nulos o negativos devuelven invalid_input en lugar de un valor complejo.