Radiciação de Radicais em Código
Sobre a Matemática
A raiz n da raiz p de um número a é igual à raiz np do mesmo número a.
Exemplos:
- ³√(²√2) = ³²√2 = ⁶√2
- √(³√1,44) = ¹²√(144/100) = ⁶√((12/10)²) = ³√(6/5)
Sobre o Código
Na linguagem de programação Python,
from – é a palavra-chave usada para importar módulos ou funções específicas de uma biblioteca.
sympy – é a biblioteca para matemática simbólica (álgebra, cálculo, simplificação de expressões).
import – é a palavra-chave usada para trazer módulos, funções ou classes para o código.
Rational() – é a função da SymPy que cria números racionais exatos (frações), evitando arredondamentos de ponto flutuante.
Pow() – é a função da SymPy que representa uma potência (ex.: Pow(2, 3) é 23.)
simplify() – é a função da SymPy que tenta simplificar uma expressão matemática para uma forma mais reduzida ou equivalente.
def – é a palavra-chave usada para definir uma função.
docstring – é o texto entre aspas triplas dentro de uma função ou classe, usado para documentar o que ela faz.
* – é o operador de multiplicação; também usado em outros contextos (como desempacotar listas/tuplas).
return – é a palavra-chave que encerra uma função e devolve um valor para quem a chamou.
print() – é a função embutida que exibe informações no console.
float() – é a função que converte um valor para o tipo numérico de ponto flutuante (decimal).
evalf() – é o método da SymPy que avalia uma expressão simbólica e retorna uma aproximação numérica em ponto flutuante.
# – é usado para criar comentários ao código, que são notas para se entender melhor o que o código faz.
Vamos ao código…
from sympy import Rational, Pow, simplify
def radical_radiation(a, n, p):
"""
Calcula a raiz n da raiz p de 'a',
mostrando que é equivalente à raiz (n*p) de 'a'.
"""
# Representação simbólica das raízes
expr1 = Pow(Pow(a, Rational(1, p)), Rational(1, n)) # √[n](√[p](a))
expr2 = Pow(a, Rational(1, n * p)) # √[np](a)
# Simplificação para verificar equivalência
return simplify(expr1), simplify(expr2)
| Código Python (.py) | O que faz |
| from sympy import Rational, Pow, simplify | Importa funções da biblioteca SymPy: Rational para frações exatas, Pow para potências/raízes, e simplify para simplificar expressões matemáticas. |
| def radical_radiation(a, n, p): | Define uma função chamada radical_radiation que recebe três parâmetros: a (o número), n (índice da raiz externa) e p (índice da raiz interna). |
| “”” … “”” | Comentário explicativo (docstring) descrevendo o propósito da função. |
| expr1 = Pow(Pow(a, Rational(1, p)), Rational(1, n)) | Calcula a expressão da raiz n da raiz p de a. Primeiro faz a^(1/p) (raiz p), depois eleva a 1/n (raiz n). |
| expr2 = Pow(a, Rational(1, n * p)) | Calcula diretamente a raiz (n*p) de a, ou seja, a^(1/(n*p)). |
| return simplify(expr1), simplify(expr2) | Retorna as duas expressões simplificadas, para comparar e verificar que são equivalentes. |
# Exemplos
a1, b1 = radical_radiation(2, 3, 2)
print("³√(²√2) =", a1, "=", b1)
a2, b2 = radical_radiation(Rational(144, 100), 2, 3)
print("√(³√(144/100)) =", a2, "=", b2)| Código Python (.py) | O que faz |
| a1, b1 = radical_radiation(2, 3, 2) | Chama a função com a=2, n=3, p=2. Isso corresponde a ³√(²√2). |
| print(“³√(²√2) =”, a1, “=”, b1) | Imprime o resultado da primeira chamada, mostrando que as duas formas são iguais. |
| a2, b2 = radical_radiation(Rational(144, 100), 2, 3) | Chama a função com a=144/100, n=2, p=3. Isso corresponde a √(³√(144/100)). |
| print(“√(³√(144/100)) =”, a2, “=”, b2) | Imprime o resultado da segunda chamada, mostrando a equivalência das duas formas. |
Saída do código (valor de retorno)…
³√(²√2) = 2**(1/6) = 2**(1/6)
√(³√(144/100)) = 5**(2/3)*6**(1/3)/5 = 5**(2/3)*6**(1/3)/5
# O SymPy mantém a forma simbólica, mas você pode converter para decimal com .evalf()
print(float(a1.evalf()))| Código Python (.py) | O que faz |
| print(float(a1.evalf())) | Essa linha imprime na tela o valor numérico (decimal) da expressão a1. Em detalhes… |
| a1.evalf() | O método .evalf() do SymPy avalia a expressão simbólica a1 em forma decimal aproximada (floating point). Por exemplo, se a1 = 2**(1/6), ele calcula o valor numérico dessa potência. |
| float(…) | Converte o resultado decimal simbólico do SymPy em um número do tipo float do Python, que é o formato padrão para números reais em ponto flutuante. |
| print(…) | Exibe o valor convertido no console. Assim, em vez de mostrar a forma simbólica 2**(1/6), o Python mostra algo como 1.122462048…. |
Saída do código (valor de retorno)…
1.122462048309373
Fonte:
- Editora Didática Paulista. Ensino Didático 2000: Ensino Fundamental e Ensino Médio. Sorocaba: Editora Didática Paulista, [s.d.].
- Códigos e comentários gerados por Microsoft Copilot com revisão nossa.
- https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]