CB2325NumericaG5 0.0.1__py3-none-any.whl

CB2325NumericaG5/interpolacao.py

@@ -0,0 +1,410 @@
+"""
+Módulo para cálculo de polinômios interpoladores.
+
+Este módulo fornece classes para construir e avaliar polinômios interpoladores a partir de
+listas de pontos no plano. Inclui implementações para:
+- interpolação de Lagrange (PoliInterp),
+- interpolação linear por partes (InterpLinear),
+- interpolação de Hermite usando valores e derivadas (PoliHermite).
+
+As classes validam entradas, constroem expressões simbólicas (SymPy) e expõem um método
+`grafico(precisao: int = 100) -> None` para esboçar o polinômio ou os segmentos.
+"""
+
+
+from sympy import symbols, simplify, lambdify, Number, latex, Symbol
+from numpy import linspace, full_like
+from matplotlib.pyplot import show, subplots
+from typing import Union
+import numbers
+
+
+class Interpolacao:
+    """
+    Classe base para verificar e armazenar os dados de entrada comuns às interpolações.
+
+    Args:
+        dominio (list): Lista de pontos do domínio (valores numéricos, distintos).
+        imagem (list): Lista de valores da função nos pontos do domínio (numéricos).
+        imagem_derivada (list | None): Lista com os valores da derivada nos pontos do domínio,
+            ou None quando não aplicável. Valor padrão: None.
+
+    Raises:
+        TypeError: Se `dominio`, `imagem` (ou `imagem_derivada`, quando fornecida) não for do tipo list,
+            ou se algum elemento das listas não for um número real.
+        ValueError: Se `dominio` e `imagem` tiverem comprimentos diferentes, se `imagem_derivada`
+            tiver comprimento diferente, se `dominio` contiver valores repetidos ou
+            se `dominio` tiver menos de 2 pontos.
+
+    Attributes:
+        x (sympy.Symbol): Símbolo interno usado para construir expressões simbólicas.
+        dominio (list): Domínio validado (lista de números reais).
+        imagem (list): Valores da função no domínio (lista de números reais).
+        imagem_derivada (list | None): Valores das derivadas no domínio (lista de números reais) ou None.
+    """
+
+
+    def __init__(self, dominio:list, imagem:list, imagem_derivada:Union[list, None] = None):
+        # Garantimos que o domínio e a imagem são listas de pontos
+        if not isinstance(dominio, list) or not isinstance(imagem, list):
+            raise TypeError('`dominio` e `imagem` devem ser do tipo list')
+
+        # Garantimos que o domínio e a imagem possuem a mesma quantidade de pontos
+        if len(dominio) != len(imagem):
+            raise ValueError('`dominio` e `imagem` devem ter a mesma quantidade de pontos')
+
+        # Garantimos que o domínio não possui pontos repetidos
+        if len(set(dominio)) != len(dominio):
+            raise ValueError('`dominio` não pode ter valores repetidos')
+
+        # Garantimos que o domínio possui mais de 2 pontos
+        if len(dominio) < 2:
+            raise ValueError('`dominio` deve possuir mais de 2 pontos')
+
+        # Garantimos que o domínio é uma lista de números
+        for i in dominio:
+            if not isinstance(i, numbers.Real):
+                raise TypeError('`dominio` deve ser uma lista de números')
+
+        # Garantimos que a imagem é uma lista de números
+        for i in imagem:
+            if not isinstance(i, numbers.Real):
+                raise TypeError('`imagem` deve ser uma lista de números')
+
+        # Cria as variáveis internas
+        self.x = symbols('x')
+        self.dominio = dominio
+        self.imagem = imagem
+
+        if imagem_derivada is not None:
+            # Garantimos que a imagem_derivada é uma lista de pontos
+            if not isinstance(imagem_derivada, list):
+                raise TypeError('`imagem_derivada` deve ser do tipo list')
+
+            # Garantimos que o domínio e a imagem_derivada possuem a mesma quantidade de pontos
+            if len(dominio) != len(imagem_derivada):
+                raise ValueError('`dominio` e `imagem` devem ter a mesma quantidade de pontos')
+
+            # Garantimos que a imagem_derivada é uma lista de números
+            for i in imagem_derivada:
+                if not isinstance(i, numbers.Real):
+                    raise TypeError('`imagem_derivada` deve ser uma lista de números')
+
+            # Cria uma variável interna
+            self.imagem_derivada = imagem_derivada
+
+    def __repr__(self):
+        raise NotImplementedError
+
+    def __call__(self, p:Union[int, float, Symbol]):
+        raise NotImplementedError
+    
+    def grafico(self, precisao:int = 100) -> None:
+        """
+        Esboça o gráfico da classe Interpolacao
+        
+        Args:
+            precisao (int, opcional): número de pontos do polinomio a serem calculados. Padroniza em 100.
+
+        Raises:
+            TypeError: se precisão não for do tipo int
+        """
+        
+        #Garante que precisao seja do tipo int
+        if not isinstance(precisao, int):
+            raise TypeError("precisao deve ser do tipo int")
+
+        #Preparação
+        x_simb = symbols('x')
+        _, ax = subplots()
+        ax.set_aspect("equal")
+        
+        #Determinação dos limites do gráfico
+        xmin, xmax, ymin, ymax = min(self.dominio), max(self.dominio), min(self.imagem), max(self.imagem)
+        mini, maxi = min(xmin, ymin), max(xmax, ymax)
+        ax.set_xlim(mini-1, maxi+1)
+        ax.set_ylim(mini-1, maxi+1)
+
+        #Conversão do polinomio
+        y_vals = linspace(xmin, xmax, precisao)
+        y_lamb = lambdify(x_simb, self.pol, "numpy")
+        y_func = y_lamb(y_vals)
+        if isinstance(y_func, (int, float)):
+                y_func = full_like(y_vals, y_func)
+        
+        #Esboço da curva e dos pontos
+        ax.plot(y_vals, y_func)
+        for i in range(len(self.dominio)):
+                x_ponto, y_ponto = self.dominio[i], self.imagem[i]
+                ax.plot(x_ponto, y_ponto, "o")
+        
+        #Exibição
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.grid(True)
+        show()
+
+
+class PoliInterp(Interpolacao):
+    """
+    Polinômio interpolador baseado no método de Lagrange.
+
+    Constrói o polinômio interpolador de Lagrange simplificado a partir de
+    listas `dominio` e `imagem` fornecidas na construção da instância.
+
+    Args:
+        dominio (list): Lista de pontos do domínio (valores numéricos distintos).
+        imagem (list): Lista de valores da função nos pontos do domínio (numéricos).
+
+    Raises:
+        ValueError: Se o ponto passado para `__call__` não for um número real nem um
+            `sympy.Symbol`, ou se o ponto numérico estiver fora do intervalo [min(dominio), max(dominio)]
+            (extrapolação não permitida).
+
+    Attributes:
+        pol (sympy.Expr): Polinômio interpolador simplificado (expressão simbólica).
+        x (sympy.Symbol): Símbolo interno herdado de Interpolacao.
+
+    Usage:
+        p = PoliInterp(dominio, imagem)
+        str(p)         # representação do polinômio
+        p(sym)         # retorna LaTeX do polinômio se sym for sympy.Symbol
+        p(valor_real)  # retorna int/float se o valor for numérico dentro do domínio
+    """
+
+    def __init__(self, dominio:list, imagem:list):
+        super().__init__(dominio, imagem)
+
+        # método de Lagrange
+        soma = 0
+        for i in range(len(self.dominio)):
+            prod = 1
+            for e in range(len(self.dominio)):
+                if e != i:
+                    prod *= (self.x - self.dominio[e]) / (self.dominio[i] - self.dominio[e])
+            soma += self.imagem[i] * prod
+
+        self.pol = simplify(soma)  # Polinômio interpolador simplificado
+
+    def __repr__(self):
+        return f'{self.pol}'
+
+    def __call__(self, p:Union[int, float, Symbol]):
+        if not isinstance(p, numbers.Real) and not isinstance(p, Symbol):
+            raise ValueError('O ponto deve ser um número real ou uma variável')
+
+        # Retorna a representação do polinômio no ponto p (variável) em LaTeX
+        if isinstance(p, Symbol):
+            return latex(self.pol.subs(self.x, p))
+
+        # Previne extrapolação
+        if p < min(self.dominio) or p > max(self.dominio):
+            raise ValueError('Valores fora do intervalo do domínio não são bem aproximados')
+
+        temp = self.pol.subs(self.x, p)
+        if isinstance(temp, Number):
+            if temp.is_integer:
+                return int(temp)
+            return float(temp)
+        return None
+
+
+class InterpLinear(Interpolacao):
+    """
+    Interpolação linear por segmentos (retas entre pares consecutivos de pontos).
+
+    Calcula e armazena retas que ligam cada par consecutivo de pontos do domínio,
+    representadas como expressões simbólicas simplificadas em um dicionário.
+
+    Args:
+        dominio (list): Lista de pontos do domínio (valores numéricos, distintos).
+        imagem (list): Lista de valores da função nos pontos do domínio (numéricos).
+
+    Raises:
+        ValueError: Se o ponto passado para `__call__` não for um número real,
+            ou se o ponto estiver fora do intervalo do domínio (extrapolação não permitida).
+
+    Attributes:
+        pares_ord (list[tuple]): Lista de pares ordenados (xi, yi) ordenados por xi.
+        pol (dict): Dicionário mapeando o intervalo (xi, xi+1) para a expressão simbólica da reta entre esses pontos.
+
+    Usage:
+        l = InterpLinear(dominio, imagem)
+        l(valor_real)  # retorna int/float se o valor estiver no domínio
+    """
+
+    def __init__(self, dominio:list, imagem:list):
+        super().__init__(dominio, imagem)
+
+        self.pares_ord = []
+        for i, e in zip(dominio, imagem):
+            self.pares_ord.append((i, e))
+        self.pares_ord = sorted(self.pares_ord)
+
+        # Criamos um dicionário para dividir as retas que ligam os pontos 2 a 2
+        self.pol = {}
+
+        # Calcula cada reta
+        for i in range(len(self.pares_ord) - 1):
+            reta = self.pares_ord[i][1] + (self.x - self.pares_ord[i][0]) * (
+                (self.pares_ord[i + 1][1] - self.pares_ord[i][1]) / (self.pares_ord[i + 1][0] - self.pares_ord[i][0]))
+
+            # Adiciona a reta simplificada no dicionário: (xi, xi+1): reta
+            self.pol[(self.pares_ord[i][0], self.pares_ord[i + 1][0])] = simplify(reta)
+
+    def __repr__(self):
+        return f'{self.pol}'
+
+    def _eval(self, pos:tuple, t:Union[int, float]):
+        temp = self.pol[pos].subs(self.x, t)
+        if isinstance(temp, Number):
+            if temp.is_integer:
+                return int(temp)
+            return float(temp)
+        return None
+
+    def __call__(self, p:Union[int, float]):
+        if not isinstance(p, numbers.Real):
+            raise ValueError('O ponto deve ser um número real')
+
+        temp = [i[0] for i in self.pares_ord]
+
+        # Extrapolação
+        if p>temp[-1] or p<temp[0]:
+            raise ValueError('Valores fora do intervalo do domínio não são bem aproximados')
+
+        for i in range(len(temp) - 1):
+            if temp[i] <= p <= temp[i + 1]:
+                return self._eval((temp[i], temp[i + 1]), p)
+        return None
+    
+    def grafico(self, precisao:int = 100) -> None:
+        """
+        Esboça o gráfico da classe InterpLinear
+        
+        Argumentos:
+            precisao (int): número de pontos do polinomio a serem calculados. Padroniza em 100.
+            
+        Raises:
+            TypeError: se precisão não for do tipo int
+        """
+        
+        #Garante que precisao seja do tipo int
+        if not isinstance(precisao, int):
+            raise TypeError("precisao deve ser do tipo int")
+        
+        #Preparação
+        x_simb = symbols('x')
+        _, ax = subplots()
+        ax.set_aspect("equal")
+        precisao = precisao//(len(self.dominio) - 1)
+        
+        #Determinação dos limites do gráfico
+        xmin, xmax, ymin, ymax = self.pares_ord[0][0], self.pares_ord[len(self.pares_ord) - 1][0], min(self.imagem), max(self.imagem)
+        mini, maxi = min(xmin, ymin), max(xmax, ymax)
+        ax.set_xlim(mini-1, maxi+1)
+        ax.set_ylim(mini-1, maxi+1)
+        
+        #Conversão do polinomio e esboço das retas
+        for i in range(1,len(self.pares_ord)):
+            y_expr = self.pares_ord[i-1][1] + (
+                x_simb - self.pares_ord[i-1][0]) * (
+                    self.pares_ord[i][1] - self.pares_ord[i-1][1]) / (
+                        self.pares_ord[i][0] - self.pares_ord[i-1][0])
+            y_vals = linspace(self.pares_ord[i-1][0], self.pares_ord[i][0], precisao)
+            y_lamb = lambdify(x_simb, y_expr, "numpy")
+            y_func = y_lamb(y_vals)
+            if isinstance(y_func, (int, float)):
+                y_func = full_like(y_vals, y_func)
+            ax.plot(y_vals, y_func)
+        
+        #Esboço dos pontos
+        for i in range(len(self.dominio)):
+                x_ponto, y_ponto = self.dominio[i], self.imagem[i]
+                ax.plot(x_ponto, y_ponto, "o")
+        
+        #Exibição
+        ax.set_xlabel("x")
+        ax.set_ylabel("y")
+        ax.grid(True)
+        show()
+
+
+class PoliHermite(Interpolacao):
+    """
+    Interpolador polinomial pelo método de Hermite (uso de valores e derivadas).
+
+    Constrói o polinômio de Hermite a partir de `dominio`, `imagem` e `imagem_derivada`,
+    usando funções auxiliares que computam os polinômios base de Hermite Hx_j e Hy_j.
+
+    Args:
+        dominio (list): Lista de pontos do domínio (valores numéricos, distintos).
+        imagem (list): Lista de valores da função nos pontos do domínio (numéricos).
+        imagem_derivada (list): Lista de valores das derivadas nos pontos do domínio (numéricos).
+
+    Raises:
+        ValueError: Se o ponto passado para `__call__` não for um número real nem um `sympy.Symbol`,
+            ou se o ponto numérico estiver fora do intervalo [min(dominio), max(dominio)] (extrapolação não permitida).
+
+    Attributes:
+        coef_lagrange (dict): Dicionário em que cada entrada j contém (L_j(x), L_j'(x)) simplificados.
+        pol (sympy.Expr): Polinômio de Hermite resultante e simplificado.
+
+    Usage:
+        h = PoliHermite(dominio, imagem, imagem_derivada)
+        str(h)           # representação do polinômio
+        h(sym)           # retorna LaTeX do polinômio se sym for sympy.Symbol
+        h(valor_real)    # retorna int/float se o valor estiver no domínio
+    """
+
+    def __init__(self, dominio:list, imagem:list, imagem_derivada:list):
+        super().__init__(dominio, imagem, imagem_derivada)
+
+        # Dicionário com os coeficientes de Lagrange
+        self.coef_lagrange = {}
+        for j in range(len(imagem)):
+            prod = 1
+            for i in range(len(dominio)):
+                if j != i:
+                    prod *= (self.x - dominio[i]) / (dominio[j] - dominio[i])
+            self.coef_lagrange[j] = (simplify(prod), simplify(prod.diff(self.x)))
+
+        # Encontra o polinômio de hermite
+        self.pol = self._hermite()
+
+    def __repr__(self):
+        return f'{self.pol}'
+
+    def _hx_j(self, j:int):
+        soma = (1-2*(self.x - self.dominio[j])*(self.coef_lagrange[j][1].subs(self.x, self.dominio[j])))*(self.coef_lagrange[j][0])**2
+        return simplify(soma)
+
+    def _hy_j(self, j:int):
+        soma = (self.x-self.dominio[j])*(self.coef_lagrange[j][0])**2
+        return simplify(soma)
+
+    def _hermite(self):
+        pol = 0
+        for j in range(len(self.dominio)):
+            pol += self.imagem[j]*self._hx_j(j) + self.imagem_derivada[j]*self._hy_j(j)
+        return simplify(pol)
+
+    def __call__(self, p:Union[int, float, Symbol]):
+        if not isinstance(p, numbers.Real) and not isinstance(p, Symbol):
+            raise ValueError('O ponto deve ser um número ou uma variável')
+
+        # Retorna a representação do polinômio no ponto p (variável) em LaTeX
+        if isinstance(p, Symbol):
+            return latex(self.pol.subs(self.x, p))
+
+        # Evita extrapolação
+        if min(self.dominio) <= p <= max(self.dominio):
+            temp = self.pol.subs(self.x, p)
+            if isinstance(temp, Number):
+                if temp.is_integer:
+                    return int(temp)
+                return float(temp)
+            return None
+
+        else:
+            raise ValueError('Valores fora do intervalo do domínio não são bem aproximados')

CB2325NumericaG5/raizes.py

@@ -0,0 +1,284 @@
+import sympy as sp
+from typing import Callable
+import numpy as np
+import matplotlib.pyplot as plt
+
+def bissecao(
+    f: Callable[[float], float],
+    a: float,
+    b: float,
+    tol: float = 1e-6,
+    max_iter: int = 100,
+    plot: bool = True
+  ) -> float:
+    """
+    Método da bisseção para encontrar uma raiz de uma função contínua em um intervalo [a, b].
+
+    O método da bisseção assume que f(a) e f(b) têm sinais opostos e procede dividindo o
+    intervalo ao meio repetidamente até que a função no ponto médio seja menor que a tolerância
+    desejada ou até atingir o número máximo de iterações.
+
+    Args:
+        f (Callable[[float], float]): Função contínua que recebe um número real e retorna um número real.
+        a (float): Ponto inicial do intervalo à esquerda.
+        b (float): Ponto inicial do intervalo à direita.
+        tol (float, optional): Tolerância para a convergência (critério em |f(c)|). Por padrão 1e-6.
+        max_iter (int, optional): Número máximo de iterações a serem executadas. Por padrão 100.
+        plot (bool, optional): Se True, exibe o gráfico das iterações. Padrão: True.
+
+    Raises:
+        ValueError: Se f(a) e f(b) não tiverem sinais opostos.
+
+    Returns:
+        float: Uma aproximação da raiz encontrada no intervalo [a, b].
+    """
+
+    if f(a) * f(b) > 0:
+        raise ValueError("f(a) e f(b) devem ter sinais opostos para o método da bisseção.")
+
+    x = np.linspace(a - abs(b - a) * 0.3, b + abs(b - a) * 0.3, 500)
+    y = np.array([f(xi) for xi in x])
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(x, y, linewidth=2, label='f(x)')
+    plt.axhline(0, color='black', linestyle='--', linewidth=1)
+    plt.title('Método da Bisseção')
+    plt.xlabel('x')
+    plt.ylabel('f(x)')
+    plt.grid(True, linestyle=':', linewidth=0.6)
+    plt.legend()
+
+    for i in range(max_iter):
+        c = (a + b) / 2
+
+        plt.axvline(a, color='red', linestyle=':', alpha=0.5)
+        plt.axvline(b, color='green', linestyle=':', alpha=0.5)
+        plt.axvline(c, color='orange', linestyle='--', alpha=0.8)
+
+        # pontos
+        plt.scatter([a, b, c], [f(a), f(b), f(c)],
+                    color=['red', 'green', 'orange'], s=50)
+
+        # anotação do ponto médio
+        plt.text(c, f(c), f"c{i+1}", fontsize=8, color='orange', ha='left', va='bottom')
+
+        if abs(f(c)) < tol:
+            print(f"Convergência atingida na iteração {i+1}: c = {c:.6f}")
+            break
+
+        if f(a) * f(c) < 0:
+            b = c
+        else:
+            a = c
+
+    plt.tight_layout()
+    if plot:
+        plt.show()
+    else:
+        plt.close()
+
+    return c
+
+def newton(
+    f: Callable[[sp.Symbol | float], sp.Expr | float],
+    x0: float,
+    tol: float = 1e-6,
+    max_iter: int = 100,
+    plot: bool = True
+) -> float:
+    """
+    Método de Newton (Newton-Raphson) para encontrar uma raiz de uma função utilizando
+    derivadas simbólicas via SymPy.
+
+    A função `f` deve ser tal que `f(x)` produza uma expressão manipulável pelo SymPy
+    quando `x` for um `sympy.Symbol`, ou simplesmente uma função que possa ser avaliada
+    numericamente quando lambdificada.
+
+    Usa o SymPy para calcular a derivada automaticamente e itera até que |f(x_k)| < tol
+    ou até atingir o número máximo de iterações.
+
+    Args:
+        f (Callable[[sp.Symbol | float], sp.Expr | float]): Função que define a expressão de interesse. Deve aceitar um símbolo
+            SymPy ou ser compatível com `sympify`/`lambdify`.
+        x0 (float): Chute inicial para o método de Newton.
+        tol (float, optional): Tolerância para o critério de parada em |f(x_k)|. Por padrão 1e-6.
+        max_iter (int, optional): Número máximo de iterações a serem executadas. Por padrão 100.
+        plot (bool, optional): Se True, exibe o gráfico das tangentes sucessivas. Padrão: True.
+
+    Raises:
+        ZeroDivisionError: Se a derivada num ponto for zero (divisão por zero no método).
+
+    Returns:
+        float: Aproximação da raiz obtida pelo método de Newton.
+    """
+
+    x = sp.Symbol('x')
+    expr = sp.sympify(f(x))
+    dexpr = sp.diff(expr, x)
+    f_num = sp.lambdify(x, expr, 'numpy')
+    df_num = sp.lambdify(x, dexpr, 'numpy')
+
+    xk = x0
+    history = [x0]
+
+    for _ in range(max_iter):
+        fx = f_num(xk)
+        dfx = df_num(xk)
+
+        if abs(fx) < tol:
+            break
+        if dfx == 0:
+            raise ZeroDivisionError("Derivada nula, método de Newton falhou.")
+
+        xk = xk - fx / dfx
+        history.append(xk)
+
+    if plot:
+        x_vals = np.linspace(min(history) - 2, max(history) + 2, 800)
+        y_vals = f_num(x_vals)
+
+        plt.figure(figsize=(9, 6))
+        plt.plot(x_vals, y_vals, 'b', linewidth=1.8, label='f(x)')
+        plt.axhline(0, color='black', linestyle='--', linewidth=1)
+
+        for i in range(len(history) - 1):
+            x0 = history[i]
+            f0 = f_num(x0)
+            df0 = df_num(x0)
+            x1 = history[i + 1]
+
+            xs = np.linspace(x0 - 1.5, x0 + 1.5, 50)
+            ys = f0 + df0 * (xs - x0)
+            plt.plot(xs, ys, 'orange', linestyle='--', alpha=0.8)
+            plt.scatter(x0, f0, color='red')
+            plt.scatter(x1, 0, color='purple', marker='x', s=80)
+            plt.text(x1, 0, f"x{i+1}", color='purple', fontsize=9, va='bottom')
+
+        plt.title('Método de Newton-Raphson – Tangentes sucessivas')
+        plt.xlabel('x')
+        plt.ylabel('f(x)')
+        plt.legend()
+        plt.grid(True, linestyle=':', alpha=0.5)
+        plt.tight_layout()
+        plt.show()
+
+    return xk
+
+def secante(
+    f: Callable[[float], float],
+    a: float,
+    b: float,
+    tol: float = 1e-6,
+    max_iter: int = 100,
+    plot: bool = True
+) -> float:
+    """
+    Método da secante para encontrar uma raiz de uma função.
+
+    O método da secante é um método iterativo que aproxima a derivada por uma diferença
+    finita usando dois pontos consecutivos. Requer dois chutes iniciais a e b.
+
+    Args:
+        f (Callable[[float], float]): Função que recebe e retorna números reais.
+        a (float): Primeiro chute inicial.
+        b (float): Segundo chute inicial.
+        tol (float, optional): Tolerância para o critério de parada em |f(c)|. Por padrão 1e-6.
+        max_iter (int, optional): Número máximo de iterações a serem executadas. Por padrão 100.
+        plot (bool, optional): Se True, exibe o gráfico das iterações. Padrão: True.
+
+    Raises:
+        ZeroDivisionError: Se ocorrer divisão por zero ao calcular o próximo iterando.
+
+    Returns:
+        float: Aproximação da raiz obtida pelo método da secante.
+    """
+
+    fa, fb = f(a), f(b)
+    history = [(a, fa), (b, fb)]
+
+    for _ in range(max_iter):
+        if abs(fb - fa) < 1e-15:
+            raise ZeroDivisionError("Divisão por zero no método da secante.")
+
+        c = b - fb * (b - a) / (fb - fa)
+
+        if abs(f(c)) < tol:
+            history.append((c, f(c)))
+            break
+
+        a, b = b, c
+        fa, fb = fb, f(c)
+        history.append((b, fb))
+
+    if plot:
+        x_vals = np.linspace(min(a, b) - 2, max(a, b) + 2, 800)
+        y_vals = f(x_vals)
+
+        plt.figure(figsize=(9, 6))
+        plt.plot(x_vals, y_vals, 'b', linewidth=1.8, label='f(x)')
+        plt.axhline(0, color='black', linestyle='--', linewidth=1)
+
+        for i in range(len(history) - 1):
+            x0, f0 = history[i]
+            x1, f1 = history[i + 1]
+            m = (f1 - f0) / (x1 - x0)
+
+            xs = np.linspace(min(x0, x1) - 0.5, max(x0, x1) + 0.5, 50)
+            ys = f1 + m * (xs - x1)
+            plt.plot(xs, ys, 'orange', linestyle='--', alpha=0.7)
+
+            plt.scatter([x0, x1], [f0, f1], color=['red', 'green'])
+            plt.scatter(x1, 0, color='purple', marker='x', s=80)
+            plt.text(x1, 0, f"x{i+1}", color='purple', fontsize=9, va='bottom')
+
+        plt.title('Método da Secante – Aproximações sucessivas')
+        plt.xlabel('x')
+        plt.ylabel('f(x)')
+        plt.legend()
+        plt.grid(True, linestyle=':')
+        plt.tight_layout()
+        plt.show()
+
+    return c
+
+def raiz(f: Callable[..., object], 
+         a: float | None = None,
+         b: float | None = None,
+         x0: float | None = None,
+         tol: float = 1e-6, 
+         method: str = "bissecao", 
+         max_iter: int = 100, 
+         plot: bool = True
+    ) -> float:
+    """
+    Função auxiliar para selecionar o método de busca de raiz desejado.
+
+    Encaminha a execução para um dos métodos disponíveis:
+    - "bissecao"
+    - "secante"
+    - "newton"
+
+    Args:
+        f (Callable[..., object]): Função alvo cuja raiz se deseja encontrar.
+        a (float | None, optional): Limite esquerdo ou primeiro chute inicial (quando aplicável).
+        b (float | None, optional): Limite direito ou segundo chute inicial (quando aplicável).
+        x0 (float | None, optional): Chute inicial para o método de Newton (quando aplicável).
+        tol (float, optional): Tolerância para os métodos. Por padrão 1e-6.
+        method (str, optional): Método a ser utilizado: "bissecao", "secante" ou "newton". Por padrão "bissecao".
+        max_iter (int, optional): Número máximo de iterações. Padrão: 100.
+        plot (bool, optional): Se True, exibe gráficos. Padrão: True.
+
+    Raises:
+        ValueError: Se o método especificado for inválido.
+
+    Returns:
+        float: Aproximação da raiz obtida pelo método selecionado.
+    """
+    if method not in ("bissecao", "secante", "newton"):
+        raise ValueError("Método inválido.")
+    if method == "bissecao":
+        return bissecao(f, a, b, tol, max_iter, plot)
+    elif method == "secante":
+        return secante(f, a, b, tol, max_iter, plot)
+    elif method == "newton":
+        return newton(f, x0, tol, max_iter, plot)