Entendendo potência: o básico que todo mundo já deveria saber
Quando você vê uma expressão como 1 elevado a 2, a conta é direta. O número 1 multiplicado por si mesmo duas vezes resulta em 1. Isso é aritmética de ensino fundamental, não tem segredo. Mas o assunto fica mais interessante quando você começa a pensar em como isso se comporta fora do papel, especialmente em programação e sistemas computacionais, onde a teoria e a prática divergem de formas que podem te pegar desprevenido.
Quanto é 1 elevado a 2
A resposta matemática exata é simplesmente 1. Em notação exponencial: 1² = 1. O número um, elevado a qualquer potência — positiva, negativa, fracionária — sempre resulta em 1. Isso é uma propriedade fundamental dos números, não uma convenção arbitrária. A base 1 é um ponto fixo na função exponencial. Em Python, você escreve isso como 1 2 ou pow(1, 2). Em C, a função pow(1.0, 2.0) retorna 1.0. Em JavaScript, Math.pow(1, 2) também dá 1. Linguagens diferentes, mesma resposta, desde que você esteja lidando com aritmética exata de inteiros.
Aqui vai algo que poucos mencionam: em aritmética de ponto flutuante, existem casos onde resultados aparentemente triviais podem produzir valores ligeiramente diferentes de 1, não por erro de cálculo, mas por questões de representação binária. Isso acontece raramente com a base 1, mas em operações encadeadas onde o 1 surge como resultado intermediário, a coisa muda. Eu trabalhei num sistema financeiro alguns anos atrás onde precisávamos calcular fatores de correção exponencial para contratos de renda variável. A maior parte dos cálculos envolvia bases como 1,0001 elevadas a potências de 365 ou mais. O problema apareceu quando, num cenário específico de arredondamento, um dos fatores retornou exatamente 1.0 para entradas que, pela lógica de negócio, deveriam gerar um valor infinitesimalmente acima disso. Descobriu-se que uma etapa anterior do pipeline estava zerando variáveis antes de passesar para a função de potência, e a função pow() do C, quando recebe uma base exatamente 1.0, retorna 1.0 de forma agressivamente otimizada, sem manter precisão de pontos decimais subsequentes.
👉 Clique no botão abaixo para saber mais sobre o assunto!
A solução foi substituir chamadas diretas a pow() por uma implementação própria que força o cálculo passo a passo quando a base está num intervalo próximo a 1 — digamos, entre 0,999999 e 1,000001. Isso adiciona uma leve sobrecarga de CPU, mas elimina o risco de perda de precisão em críticos. Em sistemas onde você processa milhões de operações por segundo, essa diferença pode significar erros cumulativos de centavos ou reais em extratos financeiros. Outro ponto que vale lembrar: em muitos ambientes de programação, 1 elevado a 2 é tratado como constante em tempo de compilação. Compiladores otimizadores como o GCC com -O2 ou -O3 vão simplesmente substituir a expressão pelo valor 1 antes mesmo de rodar o código. Isso é normal e esperado, mas pode causar confusão se você estiver fazendo profiling ou debugging e achar que a operação está sendo executada quando, na verdade, foi eliminada pela otimização.
Se você precisa manter a operação ativa por algum motivo — teste de benchmark, por exemplo — precisa usar a flag -fno-builtin-pow no GCC ou equivalente em outros compiladores para impedir essa otimização prematura. Sem isso, seu benchmark vai medir zero ciclos de processamento e você vai tirar conclusões erradas sobre performance. Para quem está começando agora e quer praticar, a maioria das calculadoras científicas, do Windows ou do Google, resolve isso instantaneamente. A linguagem SQL tem a função POWER(1, 2) em dialectos como PostgreSQL e SQL Server. Em planilhas Excel, a fórmula =POTÊNCIA(1;2) funciona da mesma forma. Ferramentas variam, resultado é sempre o mesmo.
O único cenário onde isso deixa de ser simples é quando a base não é exatamente 1, mas sim uma aproximação flutuante. Se você tem 1.0000000000000001 elevado a 2, o resultado já não é 1 — é aproximadamente 1.0000000000000002. E em ponto flutuante de 64 bits, esse último dígito pode ser o suficiente para causar divergência em comparações de igualdade. Recomendo sempre evitar == com floats, independente do quão simples seja a operação.
