Expressão Algébrica em Código

Sobre a Matemática

Expressão algébrica é a indicação de operações a efetuar sobre letras. Assim, as expressões são: algébricas ou literais.

As expressões algébricas classificam-se em racionais, irracionais, inteiras e fracionárias.

Racionais: são as que não têm letra debaixo do radical (depois de simplificar os radicais), ou com expoente fracionário.

Irracionais: são as expressões que têm alguma letra debaixo do radical (uma vez simplificados os radicais), ou com expoente fracionário.

Inteiras: são as expressões que não têm letras em denominador com expoente negativo.

Fracionárias: quando alguma letra figura em denominador ou tem expoente negativo.

Sobre o Código

Na linguagem de programação Python,

from – é a palavra-chave usada para importar módulos ou partes específicas de uma biblioteca.

sympy – é a biblioteca para matemática simbólica, usada para manipular expressões algébricas, resolver equações, calcular integrais, etc. O SymPy fornece ferramentas para transformar texto em expressões matemáticas e analisar sua estrutura (variáveis, expoentes, radicais, frações).

import – é a palavra-chave que traz funções, classes ou módulos externos para dentro do código.

symbols('x y') – cria variáveis simbólicas chamadas x e y. Essas variáveis representam letras em expressões algébricas, permitindo que o SymPy manipule equações como se fossem objetos matemáticos.

sqrt – representa a operação de raiz quadrada. No código, é usado para construir expressões como sqrt(x), que são classificadas como irracionais.

Rational – cria números racionais (frações exatas). Por exemplo, Rational(1,2) representa 1/2.

sympify(expr_str) – converte uma string (texto digitado pelo usuário, como “3x + y”) em uma expressão simbólica que o *SymPy consegue analisar e manipular. Sem isso, o programa não conseguiria aplicar regras matemáticas sobre o texto.

any() – é a função embutida que retorna True se pelo menos um elemento de um iterável for verdadeiro; caso contrário, retorna False.

and – é o operador lógico que retorna True apenas se ambas as condições forem verdadeiras.

or – é o operador lógico que retorna True se pelo menos uma das condições for verdadeira.

not – é o operador lógico que inverte o valor lógico: not True vira False, e not False vira True.

for..in..: – é a estrutura de repetição (loop) que percorre elementos de uma lista, conjunto ou outro iterável.

if – é a estrutura condicional que executa um bloco de código apenas se a condição for verdadeira.

.append() – é o método de listas que adiciona um novo elemento ao final da lista.

expr.atoms() – retorna os elementos básicos (átomos) da expressão, como variáveis (x, y), números e operadores. O código percorre esses átomos para verificar se há expoentes negativos ou fracionários.

expr.as_numer_denom() – separa a expressão em numerador e denominador. Isso permite verificar se alguma variável aparece no denominador, o que caracteriza uma expressão fracionária.

term.is_Pow – verifica se um termo é uma potência (algo elevado a um expoente). Usado para identificar casos como 𝑥^{− 2} ou 𝑥^1/3.

term.exp.is_negative – checa se o expoente é negativo. Se for, significa que a variável está no denominador (exemplo: 𝑥^-1 = 1/2).

term.exp.is_Rational – verifica se o expoente é uma fração (racional). Isso ajuda a identificar irracionais como 𝑥^1/2.

term.exp.is_Integer – verifica se o expoente é um número inteiro. Se não for inteiro, mas racional, a expressão é considerada irracional.

term.base.has(x, y) – checa se a base da potência contém as variáveis x ou y. Isso garante que estamos analisando radicais com letras, não apenas números.

print() – é a função embutida que exibe informações na tela/console.

f"..{}" (f-string, string formatada) – permite inserir valores de variáveis dentro de uma string usando {}.

# – é 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 symbols, sqrt, Rational, sympify

# Definição de variáveis simbólicas
x, y = symbols('x y')

def classificar_expressao(expr_str):
    expr = sympify(expr_str)  # converte string para expressão simbólica
    
    # Verifica se é fracionária (letra no denominador ou expoente negativo)
    fracionaria = any(term.is_Pow and term.exp.is_negative for term in expr.atoms())
    fracionaria = fracionaria or any(term.is_Symbol and expr.as_numer_denom()[1].has(term) for term in expr.atoms())
    
    # Verifica se é irracional (letra dentro de radical ou expoente fracionário)
    irracional = any(term.is_Pow and term.exp.is_Rational and not term.exp.is_Integer for term in expr.atoms())
    irracional = irracional or any(term.is_Pow and term.base.has(x, y) and term.exp == Rational(1,2) for term in expr.atoms())
    
    # Se não for irracional, é racional
    racional = not irracional
    
    # Inteira: não tem letras no denominador nem expoente negativo
    inteira = not fracionaria
    
    classificacoes = []
    if racional:
        classificacoes.append("Racional")
    if irracional:
        classificacoes.append("Irracional")
    if inteira:
        classificacoes.append("Inteira")
    if fracionaria:
        classificacoes.append("Fracionária")
    
    return classificacoes

# Exemplos de uso
expressoes = ["3*x + y", "sqrt(x) + 2", "1/x + y", "x**(-2) + y", "x**(1/3) + 5"]

for e in expressoes:
    print(f"Expressão: {e} -> Classificação: {classificar_expressao(e)}")

Saída do código (valor de retorno)…

Expressão: 3*x + y -> Classificação: ['Racional', 'Inteira']
Expressão: sqrt(x) + 2 -> Classificação: ['Racional', 'Inteira']
Expressão: 1/x + y -> Classificação: ['Racional', 'Fracionária']
Expressão: x**(-2) + y -> Classificação: ['Racional', 'Fracionária'] Expressão: x**(1/3) + 5 -> Classificação: ['Racional', 'Inteira']

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]