CB2325NumericaG5 0.0.1__py3-none-any.whl

CB2325NumericaG5/aproximacao.py

@@ -0,0 +1,251 @@
+from CB2325NumericaG5.graficos_aproximacao import grafico_ajuste_linear, grafico_ajuste_polinomial 
+
+def media(dado: list) -> float:
+    """Esta função retorna a média dos elementos da lista dada.
+
+    Args:
+        dado (list): Números (inteiros ou float).
+
+    Raises:
+        ValueError: A lista está vazia.    
+
+    Returns:
+        float: A média aritmética dos dados fornecidos.
+    """    
+    if len(dado) == 0:
+        raise ValueError("A lista está vazia.")
+
+    soma = sum(dado)
+
+    return float(soma/(len(dado))) #deixado float explícito aqui - não era necessário, mas fica mais claro
+    
+def coeficiente_determinacao(valores_y:list, valores_y_ajustados:list) -> float:
+    """Calcula o coeficiente de determinação R² para avaliar a qualidade do ajuste.
+
+    Args:
+        valores_y (list): Valores reais de y.
+        valores_y_ajustados (list): Valores ajustados de y pela regressão.
+
+    Raises:
+        ValueError: As listas de valores_y e valores_y_ajustados devem ter o mesmo tamanho.
+
+    Returns:
+        float: O coeficiente de determinação R².
+    """
+    if len(valores_y) != len(valores_y_ajustados):
+        raise ValueError("As listas de valores_y e valores_y_ajustados devem ter o mesmo tamanho.")
+
+    y_medio = media(valores_y)
+    soma_erros_quadrados = sum((y - valores_y_ajustados[i]) ** 2 for i, y in enumerate(valores_y))
+    soma_total_variacao = sum((y - y_medio) ** 2 for y in valores_y)
+
+    if soma_total_variacao == 0:
+        return 0.0
+
+    r_quadrado = 1 - (soma_erros_quadrados / soma_total_variacao)
+
+    return r_quadrado
+
+def regressao_linear(valores_x:list, valores_y:list, mostrar_grafico: bool = True, coeficiente_determinacao_r: bool = True) -> tuple :
+    """Calcula os coeficientes (angular,linear) da reta que melhor se ajusta aos dados.
+    Args:
+        valores_x (list): Coordenada x de cada ponto.
+        valores_y (list): Coordenada y de cada ponto.
+        mostrar_grafico (bool, optional): Indica se o gráfico de dispersão e a reta de ajuste
+        devem ser exibidos automaticamente. Por padrão, é True.
+        coeficiente_determinacao_r (bool, optional): Indica se o coeficiente de determinação R² deve ser calculado e exibido no terminal. Por padrão, é True.
+
+    Raises:
+        ValueError: A quantidade de abcissas deve ser igual à de ordenadas.
+
+    Returns:
+        tuple: Coeficientes da reta de regressão linear. (Coeficiente angular,Coeficiente linear)
+    """
+    if len(valores_x) != len(valores_y):
+        raise ValueError("A quantidade de abcissas deve ser igual à de ordenadas.")
+
+    den_beta_chapeu =  -len(valores_x)*(media(valores_x)*media(valores_x))
+    num_beta_chapeu =  -len(valores_x)*media(valores_x)*media(valores_y)
+
+    for k in range(len(valores_x)):
+        den_beta_chapeu += valores_x[k]*valores_x[k]
+        num_beta_chapeu += valores_x[k]*valores_y[k]
+    
+    beta_chapeu = num_beta_chapeu/den_beta_chapeu
+    alpha_chapeu = media(valores_y) - beta_chapeu*media(valores_x)
+    r_quadrado = coeficiente_determinacao(valores_y,[beta_chapeu*x + alpha_chapeu for x in valores_x])
+
+    if mostrar_grafico == True:
+        grafico_ajuste_linear(valores_x,valores_y,beta_chapeu,alpha_chapeu,r_quadrado)
+    
+    if coeficiente_determinacao_r == True:
+        print(f"Coeficiente de Determinação R²: {r_quadrado:.2f}")
+    
+    return (beta_chapeu,alpha_chapeu)
+
+def resolvedor_de_sistemas(MC:list, VI:list, tolerancia:float = 1e-11) -> list:
+    """Resolve Sistemas Lineares. Medios e grandes é por Gauss-Jordan.
+
+    Args:
+        MC (list): Os coeficientes das incognitas do sistema linear.
+        VI (list): Os coeficientes independentes das variáveis.
+        tolerancia (float, optional): Abaixo desse valor o número é considerado zero; isso para que não haja divisões por números muito pequenos. Defaults to 1e-11.
+
+    Raises:
+        ValueError: Sistema impossível de ser resolvido, alguma linha deu apenas 0.
+
+    Returns:
+        list: Lista do valor de cada incognita, caso venha na ordem MC = [[a_x + a_y + a_z + ...], [b_x + b_y+...], ...], a resposta virá em [x,y,z,...].
+    """    
+    Matriz_Coeficientes = list(MC)
+    Vetor_Independentes = list(VI)
+    Matriz_Aumentada = [Matriz_Coeficientes[e] + [Vetor_Independentes[e]] for e in range(len(Vetor_Independentes))]
+
+    def prod_linha(linha:list, produtado:float, div=False) -> list[float]:
+
+        auxiliar = [r for r in linha]
+
+        if div == True:
+            for r in range(len(linha)):
+                auxiliar[r] /= produtado
+
+        else:
+            for r in range(len(linha)):
+                auxiliar[r] *= produtado
+
+        return auxiliar
+    
+    def soma_linha_linha(linha:list, somado:list, sub:bool =False) -> list[float]:
+        auxiliar = [r for r in linha]
+
+        if sub == True:
+            for r in range(len(linha)):
+                auxiliar[r] -= somado[r]
+
+        else:
+            for r in range(len(linha)):
+                auxiliar[r] += somado[r]
+        
+        return auxiliar
+
+    for kk in range(len(Vetor_Independentes)):
+        linhas_trocadas = False
+        if abs(Matriz_Aumentada[kk][kk]) <= tolerancia:
+            for j in  range(kk+1, len(Vetor_Independentes)):
+                if abs(Matriz_Aumentada[j][kk]) > tolerancia:
+                    Matriz_Aumentada[j], Matriz_Aumentada[kk] = Matriz_Aumentada[kk], Matriz_Aumentada[j]
+                    linhas_trocadas = True
+                    break
+
+            if linhas_trocadas == False:
+                raise ValueError ("Sistema sem solução única.")
+
+        e = Matriz_Aumentada[kk][kk]
+        transicao = list(Matriz_Aumentada[kk])
+        Matriz_Aumentada[kk] = prod_linha(transicao, e, True) #Divide aquela linha pelo elemento da diagonal.
+
+        for i in range(kk+1, len(Vetor_Independentes)): #Processo de triangulação
+            if abs(Matriz_Aumentada[i][kk]) <= tolerancia:
+                Matriz_Aumentada[i][kk] = 0
+                continue
+            variavel_de_suporte1 = Matriz_Aumentada[i][kk]
+            variavel_de_suporte2 = prod_linha(Matriz_Aumentada[kk], variavel_de_suporte1)
+            Matriz_Aumentada[i] = soma_linha_linha(Matriz_Aumentada[i], variavel_de_suporte2, True)
+
+    #A partir daqui já temos uma matriz triangular superior.
+    x = [0 for i in range(len(Vetor_Independentes))]
+
+    for i in reversed(range(len(Vetor_Independentes))):
+        soma = sum(Matriz_Aumentada[i][j] * x[j] for j in range(i + 1, len(Vetor_Independentes)))
+        x[i] = (Matriz_Aumentada[i][-1] - soma) / Matriz_Aumentada[i][i]
+
+    return x #retorna [x,y,z,...]
+
+def aproximacao_polinomial(lista_de_coordenadas:list, grau_do_polinomio:int, mostrar_grafico: bool = True, coeficiente_determinacao_r: bool = True) -> list[float]:
+    """Utiliza MMQ para fazer a regressão polinomial dos pontos dados. Tudo no plano. Retorna os coeficientes.
+
+    Args:
+        lista_de_coordenadas (list): Uma lista dos pontos cuja função vai aproximar.
+        grau_do_polinomio (int): Qual tipo de polinômio a função retornará. 1 é linear, por exemplo.
+        mostrar_grafico (bool, optional): Indica se o gráfico de dispersão e a curva ajustada
+        devem ser exibidos automaticamente. Por padrão, é True.
+        coeficiente_determinacao_r (bool, optional): Indica se o coeficiente de determinação R² deve ser calculado e exibido no terminal. Por padrão, é True.
+
+    Raises:
+        KeyError: Caso haja menos dados do que o número do grau do polinômio requerido, existirão infinitas "soluções". 
+
+    Returns:
+        list: Lista dos coeficientes em ordem crescente de grau.
+    """    
+    quantidade_de_pontos = len(lista_de_coordenadas)
+
+    if quantidade_de_pontos < grau_do_polinomio+1: #Condição necessária para que um polinômio seja encontrado.
+        raise KeyError("A quantidade de dados deve ser maior ou igual ao grau do polinômio desejado.")
+    #(
+    valores_x = [e for e,ee in lista_de_coordenadas]
+    valores_y = [ee for e,ee in lista_de_coordenadas]
+    # )Isola cada conjunto de dados de cada coordenada num vetor.
+
+    matriz_valores_x = [[e**i for e in valores_x] for i in range(grau_do_polinomio+1)]
+
+    #Feita a matriz de cada xis nos devidos graus para que o polinômio seja encontrado.
+    def produto_de_linhas(linha1:list, linha2:list) -> float: #Retorna o elemento da matriz resultado, quando se trata do produto de matrizes.
+        """Executa uma operação entre listas do mesmo tamanho.
+
+        Args:
+            linha1 (list): Lista de floats.
+            linha2 (list): Lista de floats.
+
+        Returns:
+            int: O resultado do "produto interno" dos "vetores" fornecidos.
+        """        
+        contador = 0
+        if len(linha1) == len(linha2):
+            for i in range(len(linha1)):
+                contador += linha1[i]*linha2[i]
+
+        return contador
+
+    matriz_produto_valores_x = [[produto_de_linhas(matriz_valores_x[i],matriz_valores_x[ii]) for i in range(len(matriz_valores_x))] for ii in range(len(matriz_valores_x[0])+1 - len(valores_x)+grau_do_polinomio)] #Menos um ou menos 2? Talvez 1 - (quantidade de dados - grau do polinomio)
+    #A matriz que define o sistema de equações que deve ser resolvido. A outra é:
+
+    vetor_valores_y_do_sistema = [produto_de_linhas(valores_y,matriz_valores_x[i]) for i in range(len(matriz_valores_x))]
+    vetor_solucao = resolvedor_de_sistemas(matriz_produto_valores_x,vetor_valores_y_do_sistema)
+    valores_y_ajustados = [
+        sum(vetor_solucao[i]*(x**i) for i in range(len(vetor_solucao))) 
+        for x in valores_x
+    ]
+
+    r_quadrado = coeficiente_determinacao(valores_y,valores_y_ajustados)
+
+    if mostrar_grafico == True:
+        grafico_ajuste_polinomial(valores_x, valores_y, vetor_solucao, r_quadrado)
+
+    if coeficiente_determinacao_r == True:
+        print(f"Coeficiente de Determinação R²: {r_quadrado:.2f}")
+    
+    return vetor_solucao
+
+def txt_aproximacao_polinomial(lista_de_coordenadas:list, grau_do_polinomio:int) -> str:
+    """Utiliza MMQ para fazer a regressão polinomial dos pontos dados. Tudo no plano. Retorna o polinômio.
+
+    Args:
+        lista_de_coordenadas (list): Uma lista dos pontos cuja função vai aproximar.
+        grau_do_polinomio (int): Qual tipo de polinômio a função retornará. 1 é linear, por exemplo.
+
+    Returns:
+        str: O polinômio na sua forma por extenso.
+    """    
+    k = str()
+    a = aproximacao_polinomial(lista_de_coordenadas,grau_do_polinomio, False, False) #não mostrar o gráfico e o R² duas vezes
+
+    for i in range(len(a)):
+        if a[len(a)-1-i] > 0:
+            k+=f"({a[len(a)-1-i]:.3})x^{len(a)-i-1}"
+        elif a[len(a)-1-i] == 0:
+            continue
+        else:
+            k+=f" + ({a[len(a)-1-i]:.3})x^{len(a)-i-1} "
+
+    return k
+

CB2325NumericaG5/erros.py

@@ -0,0 +1,104 @@
+"""
+Módulo para cálculo de erros numéricos.
+
+Esse módulo fornece funções para calcular o erro absoluto e o erro relativo entre um valor real e um valor aproximado.
+"""
+from typing import List
+
+
+def erro_absoluto(valor_real: float, valor_aprox: float, casas_decimais: int = 6) -> float:
+    """
+    Retorna o erro absoluto entre o valor real de um número e seu valor aproximado,
+    de acordo com a quantidade desejada de casas decimais.
+    Calcula o erro absoluto entre dois valores de um mesmo número: seu valor real e seu valor
+    aproximado. O erro absoluto é calculado por meio do módulo da diferença entre o valor real e o 
+    valor aproximado.
+    
+    Args:
+        valor_real (float): É o valor real (ou exato, caso seja) do número
+        valor_aprox (float): É o valor aproximado do número
+        casas_decimais (int, optional): Número de casas decimais do resultado. Por padrão, é 6.
+
+    Returns:
+        float: Resultado do cálculo do erro absoluto
+        
+    Raises:
+        TypeError: se o `valor_real` e o `valor_aprox` não forem float ou int
+        ValueError: se `casas_decimais` não for um inteiro não negativo
+    """
+    if not isinstance(valor_aprox, (int, float)) or not isinstance(valor_real, (int, float)):
+        raise TypeError("O valor real e o valor aproximado devem ser números reais.")
+    if not isinstance(casas_decimais, int) or casas_decimais<0:
+        raise ValueError("O número de casas decimais deve ser um inteiro não-negativo.")
+    erro = abs(valor_real - valor_aprox)
+    return round(erro, casas_decimais)
+
+def erro_relativo(valor_real: float, valor_aprox: float, casas_decimais: int = 6) -> float:
+    """
+    Retorna o erro relativo entre o valor real de um número e seu valor aproximado, de acordo 
+    com a quantidade desejada de casas decimais.
+    O erro relativo é o erro absoluto dividido pelo valor absoluto do valor real.
+    Fórmula: E_r=|(valor_real-valor_aprox)/valor_real|
+
+    Args:
+        valor_real (float): O valor exato ou de referência. Deve ser diferente de zero.
+        valor_aprox (float): O valor obtido por medição ou aproximação.
+        casas_decimais (int, optional): Número de casas decimais do resultado. Por padrão, é 6.
+        
+    Returns:
+        float: O erro relativo calculado, arredondado para o número de casas decimais 
+        especificado em `casas_decimais`.
+        
+    Raises:
+        ValueError: Se o `valor_real` for zero, o que causaria divisão por zero.
+        TypeError: se o `valor_real` e o `valor_aprox` não forem float ou int
+        ValueError: se `casas_decimais` não for um inteiro não negativo
+    """
+    
+    if valor_real==0:
+        raise ValueError("O valor real não pode ser zero para o cálculo do erro relativo.")
+    if not isinstance(valor_aprox, (int, float)) or not isinstance(valor_real, (int, float)):
+        raise TypeError("O valor real e o valor aproximado devem ser números reais.")
+    if not isinstance(casas_decimais, int) or casas_decimais<0:
+        raise ValueError("O número de casas decimais deve ser um inteiro não-negativo.")
+    
+    return round(abs((valor_real-valor_aprox)/valor_real), casas_decimais)
+
+def soma_de_kahan(lista_de_valores: List[float]) -> float:
+    """
+    O algoritmo de soma de Kahan é um método de análise numérica que
+    visa minimizar o erro numérico (erro de arredondamento) ao somar 
+    uma sequência de números de ponto flutuante de precisão finita. 
+    Se o usuário decidir somar uma lista de números que possua valores 
+    muito grandes e valores muito pequenos, como a precisão dos computadores
+    é limitida, os dígitos de baixa ordem (menos significativos) do número 
+    pequeno podem ser perdidos durante a operação de adição devido ao 
+    arrendondamento. Para minimizar essa falha, o algoritmo da soma de Kahan
+    mantém uma variável de "compensação" durante a realização da soma, a qual
+    acumula os dígitos de baixa ordem "perdidos" a cada etapa da operação. A
+    cada nova etapa de adição, esse erro é usado para "ajustar" o próximo número
+    que será somado, compensando a perda de precisão do anterior.
+
+    Args:
+        lista_de_valores (List[float]): A lista dos valores de ponto fluante que se deseja somar
+
+    Returns:
+        float: Retorna a soma compensada dos números de ponto flutuante fornecidos
+    """
+    
+    if not isinstance(lista_de_valores, list):
+        raise TypeError ("a lista de valores fornecida deve ser uma lista")
+    
+    soma_total = 0.0 # a soma corrente 
+    compensação = 0.0 # a variável que será a compensação
+    
+    for valor in lista_de_valores: 
+        if not isinstance(valor, float) and not isinstance(valor, int): # se o valor fornecido não for um float ou um inteiro, a operação não é realizada
+            continue 
+        
+        v = valor - compensação # a cada valor, desconta-se a compensação
+        soma_auxiliar = soma_total + v # a soma auxiliar pega a soma total corrente e adicona o valor após a compensação
+        compensação = (soma_auxiliar - soma_total) - v # a compensação é atualizada 
+        soma_total = soma_auxiliar # a soma total corrente é atualizada com o valor da soma armazenada na variável auxiliar
+    
+    return soma_total 

CB2325NumericaG5/graficos_aproximacao.py

@@ -0,0 +1,60 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def grafico_ajuste_linear(valores_x:list, valores_y:list, coeficiente_angular:float, coeficiente_linear:float, r_quadrado:float) -> None:
+    """Gera o gráfico de dispersão dos pontos e a reta de ajuste linear.
+    Args:
+        valores_x (list): Coordenada x de cada ponto.
+        valores_y (list): Coordenada y de cada ponto.
+        coeficiente_angular (float): Coeficiente angular da reta de ajuste linear.
+        coeficiente_linear (float): Coeficiente linear da reta de ajuste linear.
+        r_quadrado (float): Coeficiente de determinação R².
+    """
+    plt.scatter(valores_x, valores_y, color='blue', label='Pontos de dados')
+    
+    x_min = min(valores_x)
+    x_max = max(valores_x)
+    y_min = coeficiente_angular * x_min + coeficiente_linear
+    y_max = coeficiente_angular * x_max + coeficiente_linear
+
+    plt.plot([x_min, x_max], [y_min, y_max], color='red', label=f'Reta de Ajuste Linear (R² = {r_quadrado:.2f})')
+
+    plt.xlabel('Valores X')
+    plt.ylabel('Valores Y')
+    plt.title('Ajuste Linear')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+    return None
+
+
+#versão utilizando numpy - a reta de ajuste fica mais suave
+def grafico_ajuste_polinomial(valores_x:list, valores_y:list, coeficientes:list, r_quadrado:float) -> None:
+    """Gera o gráfico de dispersão dos pontos e a curva de ajuste polinomial.
+    Args:
+        valores_x (list): Coordenada x de cada ponto.
+        valores_y (list): Coordenada y de cada ponto.
+        coeficientes (list): Coeficientes do polinômio de ajuste.
+        r_quadrado (float): Coeficiente de determinação R².
+    """
+    plt.scatter(valores_x, valores_y, color='blue', label='Pontos de dados')
+
+    #cria 200 pontos igualmente espaçados entre o min e o max de x para uma curva mais suave
+    intervalo_x = np.linspace(min(valores_x), max(valores_x), 200) 
+
+    valores_y_ajustados = []
+    #calcula e adiciona os valores de y ajustados usando a expressão do polinomio 
+    for x in intervalo_x:
+        y=0
+        for i in range(len(coeficientes)):
+            y += coeficientes[i] * (x ** i)
+        valores_y_ajustados.append(y)
+
+    plt.plot(intervalo_x, valores_y_ajustados, color='red', label=f'Curva de Ajuste Polinomial (R² = {r_quadrado:.2f})')
+
+    plt.xlabel('Valores X')
+    plt.ylabel('Valores Y')
+    plt.title('Ajuste Polinomial')
+    plt.legend()
+    plt.grid(True)
+    plt.show()

CB2325NumericaG5/integracao.py

@@ -0,0 +1,190 @@
+"""
+Módulo de integração numérica — cálculo e visualização de integrais definidas.
+
+Este módulo fornece ferramentas para o cálculo numérico de integrais definidas
+de funções reais em um intervalo [a, b], utilizando dois métodos clássicos:
+- Regra dos Trapézios
+- Regra de Simpson (1/3)
+
+Além de realizar o cálculo, gera representações gráficas
+da área sob a curva, facilitando a visualização dos conceitos de integração.
+
+Exemplo de uso:
+---------------
+>>> from CB2325NumericaG5.integracao import integral
+>>> resultado = integral(lambda x: x**2, 0, 2, n=10, metodo="simpson", plot=True)
+>>> print(resultado)
+2.6667
+"""
+
+from typing import Callable, Union
+import matplotlib.pyplot as plt
+import numpy as np
+
+def _plot_parabola(x0: float, x1: float, x2: float, y0: float, y1: float, y2: float) -> None:
+    """
+    Gera a representação gráfica de uma parábola que passa por (x0,y0), (x1,y1) e (x2,y2) no intervalo [x0,x2],
+    preenchendo a área entre a curva e o eixo x.
+    
+    Esta função não retorna valor, apenas gera uma representação gráfica da parábola.
+
+    Args:
+        x0 (float): x do primeiro ponto da parábola
+        x1 (float): x do segundo ponto da parábola
+        x2 (float): x do terceiro ponto da parábola
+        y0 (float): y do primeiro ponto da parábola
+        y1 (float): y do segundo ponto da parábola
+        y2 (float): y do terceiro ponto da parábola
+    """
+    # Encontrando coeficientes a, b, c da parábola y = ax² + bx + c:
+    A = np.array([[x0**2, x0, 1],
+                  [x1**2, x1, 1], 
+                  [x2**2, x2, 1]])
+    y_vec = np.array([y0, y1, y2])
+    a, b, c = np.linalg.solve(A, y_vec)
+    
+    # Pontos da parábola
+    x_para = np.linspace(x0, x2, 50)
+    y_para = a*x_para**2 + b*x_para + c
+    
+    plt.plot(x_para, y_para, 'r--', alpha=0.7, linewidth=1)
+    plt.fill_between(x_para, 0, y_para, alpha=0.2, color='red')
+
+def integral(
+        funcao: Callable[[Union[float, np.ndarray]], Union[float, np.ndarray]],
+        a: float,
+        b: float,
+        n: int,
+        aprox: int = 4,
+        metodo: str = "simpson",
+        plot: bool = True
+    ) -> float:
+    """
+    Calcula numericamente a integral definida de uma função no intervalo [a, b],
+    utilizando o método dos trapézios ou a regra de Simpson (1/3) e 
+    gera uma representação gráfica da integral.
+    
+    Se `a > b`, o resultado será negativo, seguindo a convenção matemática.
+
+    O método dos trapézios aproxima a área sob a curva dividindo o intervalo em
+    `n` subintervalos igualmente espaçados e somando as áreas dos trapézios formados
+    entre os pontos consecutivos.
+
+    Já a regra de Simpson aproxima a integral pela soma das áreas sob polinômios quadráticos
+    que interpolam a função, proporcionando maior precisão com o mesmo número de
+    subdivisões — desde que `n` seja par.
+
+    Args:
+        funcao (Callable[[Union[float, np.ndarray]], Union[float, np.ndarray]]): Função a ser integrada.
+        a (float): Limite inferior de integração.
+        b (float): Limite superior de integração.
+        n (int): Número de subdivisões (intervalos) utilizados na aproximação. Para o método de Simpson, `n` deve ser par.
+        aprox (int, optional): Número de casas decimais para arredondamento do resultado. O padrão é 4.
+        metodo (str, optional): Método de integração numérica a ser utilizado: `"trapezios"` ou `"simpson"`. O padrão é `"simpson"`.
+        plot (bool, optional): Se True, exibe a representação gráfica da integral. O padrão é True.
+        
+    Raises:
+        ValueError: Se o método for `"simpson"` e `n` for ímpar.
+        ValueError: Se o argumento `metodo` não for `"trapezios"` nem `"simpson"`.
+        ValueError: Se `n` não for um inteiro positivo.
+        ValueError: Se `aprox` não for um inteiro não negativo.
+        TypeError: Se os limites de integração `a` e `b` não forem números reais.
+        TypeError: Se `funcao` não for chamável (callable).
+
+    Returns:
+        float: Valor aproximado da integral definida de `funcao` no intervalo [a, b],
+        arredondado para o número de casas decimais especificado em `aprox`.
+    """
+    # Validação da entrada
+    if not callable(funcao):
+        raise TypeError("O argumento 'funcao' deve ser chamável (callable).")
+    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
+        raise TypeError("Os limites de integração 'a' e 'b' devem ser números reais.")
+    if not isinstance(n, int) or n <= 0:
+        raise ValueError("O número de subdivisões 'n' deve ser um inteiro positivo (> 0).")
+    if not isinstance(aprox, int) or aprox < 0:
+        raise ValueError("O número de casas decimais 'aprox' deve ser um inteiro não negativo (>= 0).")
+    if metodo not in ("trapezios", "simpson"):
+        raise ValueError("Método inválido! Use 'trapezios' ou 'simpson'.")
+    
+    funcao_vec = np.vectorize(funcao, otypes=[float])
+
+    # Cálculo da integral
+    dx = (b - a) / n
+    soma = 0.0
+    
+    if metodo == "trapezios":
+        for i in range(n):
+            x1 = a + i * dx
+            x2 = a + (i + 1) * dx
+            soma += (float(funcao_vec(x1)) + float(funcao_vec(x2))) * dx / 2
+                
+    else: # metodo == "simpson"
+        if n % 2 != 0:
+            raise ValueError("Para o método de Simpson, o número de subintervalos 'n' deve ser par.")
+        for i in range(n + 1):
+            x = a + i * dx
+            if i == 0 or i == n:
+                soma += float(funcao_vec(x))
+            elif i % 2 == 1:
+                soma += 4 * float(funcao_vec(x))
+            else:
+                soma += 2 * float(funcao_vec(x))
+                
+        soma *= dx / 3
+
+    if plot:
+        x = np.linspace(a-0.11*(b-a), b + 0.11*(b-a), 100)
+        y = funcao_vec(x)
+
+        plt.figure(figsize=(10, 6))
+
+        plt.plot(x, y, label='f(x)', linewidth=2, linestyle='-', color='black')
+
+        plt.title(f"Integração de f(x) = {round(float(soma), aprox)} — método: {metodo.capitalize()}", fontsize=16, fontweight='bold')
+        plt.xlabel("x", fontsize=12)
+        plt.ylabel("y", fontsize=12)
+        plt.grid(True, alpha=0.3)
+        plt.legend(fontsize=12)
+
+        # Garantia do eixo x (y=0) estar sempre no gráfico
+        y_min = min(np.min(y), 0)
+        y_max = max(np.max(y), 0) 
+
+        # Margem para visualização total do gráfico
+        margem_y = 0.1 * (y_max - y_min)
+        margem_x = 0.1 * (b - a)
+        plt.ylim(y_min - margem_y, y_max + margem_y)
+        plt.xlim(a-margem_x, b + margem_x)
+
+        #Eixos x e y
+        plt.axhline(y=0, color='black', linewidth=1.5, linestyle='-')
+        plt.axvline(x=0, color='black', linewidth=1.5, linestyle='-')
+
+        # Limites da integração
+        plt.plot([a, a], [0, funcao_vec(a)], color='black', linewidth=1.5, linestyle='-')
+        plt.plot([b, b], [0, funcao_vec(b)], color='black', linewidth=1.5, linestyle='-')
+        
+        # Plot da integral
+        if metodo == "trapezios":
+            for i in range(n):
+                x_i = a + i * dx
+                x_i2 = a + (i + 1) * dx
+        
+                x_trap = [x_i, x_i, x_i2, x_i2, x_i]  # Pontos do trápezio (inf esquerdo, sup esquerdo, sup direito, inf direito)
+                y_trap = [0, funcao_vec(x_i), funcao_vec(x_i2), 0, 0] # 5º ponto para fechar o polígono
+        
+                plt.fill(x_trap, y_trap, alpha=0.3, color='orange', edgecolor='black')
+
+        else: # metodo == "simpson"
+            for i in range(0,n,2):
+                x_i = a + i * dx
+                x_i2 = a + (i + 1) * dx
+                x_i3 = a + (i + 2) * dx
+                y_i, y_i2, y_i3 = float(funcao_vec(x_i)), float(funcao_vec(x_i2)), float(funcao_vec(x_i3))
+
+                _plot_parabola(x_i, x_i2, x_i3, y_i, y_i2, y_i3)
+
+        plt.show()
+
+    return round(float(soma), aprox)