Expandir e condensar logaritmos
Expanda log(x²y/z) em 2 log x + log y − log z, ou junte essa soma em um único logaritmo, com cada lei indicada passo a passo. Aceita ln, logaritmo na base dez, base dois ou qualquer base válida. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Roda direto no seu navegador. Grátis, sem cadastro — seus dados não são enviados para lugar nenhum.
Uma ferramenta para expandir e condensar logaritmos reescreve expressões com as três leis clássicas de todo curso de álgebra. Expandir transforma um log de um produto, quociente ou fator elevado em uma soma de logs mais simples; condensar faz o inverso e empacota uma combinação linear de logs em um único log de produto ou quociente. Você envia um modo, uma base opcional (natural, comum, binária ou qualquer número válido) e uma lista de argumentos positivos com potências ou coeficientes. A resposta devolve a expressão de entrada, o resultado reescrito, termos estruturados, as leis aplicadas e linhas passo a passo que você pode conferir com a lição ou testes unitários.
Leis de produto, quociente e potência dos logaritmos
Três identidades reescrevem quase toda expressão logarítmica de sala sobre os reais positivos. A lei do produto diz que o log de um produto é a soma dos logs: log de A vezes B é log A mais log B, para qualquer base fixa maior que zero e diferente de um. A lei do quociente diz que o log de um quociente é uma diferença: log de A sobre B é log A menos log B.
A lei da potência diz que o log de uma potência traz o expoente à frente: log de A à n é n vezes log A. Combinadas, log de x ao quadrado vezes y sobre z expande em dois log x mais log y menos log z. Condensar percorre o mesmo caminho ao contrário: uma soma de coeficiente vezes log vira um log de um produto de fatores elevados, com coeficientes negativos no denominador.
Bases podem ser a natural e escrita como ln, a comum dez, a binária dois, um log genérico sem subscrito ou qualquer outra base numérica válida. Argumentos devem ser estritamente positivos quando são números; símbolos são tratados como variáveis de sala que representam quantidades positivas. Zero e negativos numéricos são erros de domínio, não escolhas estéticas, e esta ferramenta os recusa em vez de devolver um valor complexo.
Professores usam as mesmas três leis para exercícios de simplificação, gabaritos e checagens de álgebra computacional, de modo que uma resposta determinística de expandir ou condensar com leis nomeadas é mais útil que uma simplificação caixa-preta que esconde qual identidade disparou.
Dicas práticas, limites e buscas relacionadas
Mantenha cada argumento numérico estritamente positivo e cada base numérica positiva e diferente de um para respeitar o domínio do logaritmo real. Prefira símbolos para lição puramente algébrica e números quando também quiser checagens de domínio em valores concretos. Limite cada requisição a no máximo trinta e dois termos e valores absolutos de no máximo um trilhão para que a formatação intermediária continue legível.
Fatores de potência zero não contribuem e são pulados com um passo explícito. Esta landing mira quem busca expandir logaritmo, condensar logs, calculadora de regra produto quociente potência ou leis logarítmicas online; não é avaliador numérico de mudança de base, nem CAS simbólico completo, nem solucionador de equações logarítmicas. Prefira esta capacidade quando você já tem fatores ou parcelas e só precisa da reescrita por leis; se a fonte for string livre com parênteses aninhados, faça o parse em terms primeiro.
Casos de uso
Testes unitários para simplificadores logarítmicos de alunos
Gere casos conhecidos de expandir e condensar mais rejeições deliberadas de argumentos não positivos como valores esperados de kata de programação.
Perguntas frequentes
O que o modo expand faz?
Expand pega um logaritmo de um produto, quociente ou fatores elevados (seus terms como arg^power dentro do log) e reescreve como soma de coeficiente vezes log(arg) usando as leis de produto, quociente e potência.
O que o modo condense faz?
Condense pega uma soma de termos power·log(arg) e reescreve como um único log de um produto/quociente dos argumentos elevados.
Quais bases são suportadas?
Omita base para log genérico, use e/ln para natural, 10 para comum, 2 para binário, ou qualquer positivo diferente de 1. Bases inválidas são rejeitadas.
A ferramenta de expandir logaritmos é gratuita?
A ferramenta do navegador é gratuita e roda localmente.
Por que os números dentro do logaritmo precisam ser positivos?
Porque o logaritmo real só é definido para valores positivos, então um número igual a zero ou negativo é recusado. Letras como x ou y são tratadas como quantidades positivas, como é comum em sala de aula.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"mode": "expand",
"terms": [
{
"arg": "x",
"power": 2
},
{
"arg": "y",
"power": 1
},
{
"arg": "z",
"power": -1
}
]
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.log_expand",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_terms | 32 |
max_abs | 1000000000000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Argumentos numéricos nulos ou negativos são rejeitados com invalid_input porque saem do domínio do logaritmo real. O caminho é reescrita determinística pura —sem rede, sem sementes aleatórias, sem relógio— de modo que o executor gratuito do navegador e a API pré-paga devolvem o mesmo JSON sempre.
Como chamar a API e o que volta
No modo expand os termos são fatores dentro de um único logaritmo: arg elevado a power multiplica dentro do log, e potências negativas viram fatores de quociente. No modo condense os mesmos campos significam power vezes log de arg em uma soma que colapsa em um log. Envie um corpo JSON com mode obrigatório em expand ou condense, base opcional como string ou número, e terms obrigatório como array não vazio de objetos. Cada termo precisa de arg, um número positivo ou um símbolo simples como x ou a1, e pode incluir power (aliases coeff, coefficient, exp, n) com padrão um. Aliases mode operation e action, base log_base e radix, e terms factors e parts são aceitos. Em sucesso a resposta inclui mode, base, base_label como ln ou log_10, input_expression, result_expression, um array terms com coeff, arg e strings de expressão por termo, laws_applied listando power product quotient ou identity, steps ordenados e um message curto. Validação falha —mode ou terms ausentes, terms vazio, mais de trinta e dois termos, base inválida um ou não positiva, potências não finitas ou argumento numérico não positivo— devolve invalid_input e nunca é cobrada. O preço é um fixo US$ 0,002 por requisição bem-sucedida com unidade item e preço marginal unitário zero.
Dicas práticas, limites e buscas relacionadas
Ao ensinar, pareie exemplos: expanda log_10 de x ao quadrado vezes y sobre z em dois log_10 x mais log_10 y menos log_10 z; condense dois ln a mais ln b em ln de a ao quadrado vezes b; e envie de propósito arg menos três para mostrar o caminho duro invalid_input em argumentos não positivos. Tarefas falhas com invalid_input não consomem saldo pré-pago, o que mantém scripts exploratórios baratos quando aprendizes sondam o domínio. Checagens de ida e volta são fáceis: expandir e depois condensar com a mesma base e terms deve recuperar forma de produto equivalente, e a lista laws_applied deve mencionar cada identidade que você espera para entradas multi-fator de sinais mistos.
Casos de integração
Conferência de lição sobre reescritas de leis logarítmicas
Alunos informam fatores com potências e comparam passos manuscritos de expandir ou condensar com result_expression e lista laws_applied determinísticos antes de entregar.
Gabaritos de exercícios para professores
Monte gabaritos que mostrem input_expression, result_expression e passos ordenados para treinos de produto, quociente e potência em ln, log_10 e log genérico.
Perguntas técnicas
Por que os argumentos devem ser positivos?
Nos reais, log_b(x) só é definido para x > 0 (com base b > 0, b ≠ 1). Argumentos numéricos nulos ou negativos devolvem invalid_input em vez de um valor complexo.