mnspy 0.9.18__tar.gz → 0.9.20__tar.gz

mnspy-0.9.20/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Edwin Córdoba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{mnspy-0.9.18 → mnspy-0.9.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnspy
-Version: 0.9.18
+Version: 0.9.20
 Summary: Paquete didáctico para métodos numéricos
 Home-page: https://github.com/EdwinSoft/mnspy
 Author: Edwin Córdoba

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/bisecci/303/263n.py

@@ -23,7 +23,8 @@ class Biseccion(Raices):
         Tipo de error a utilizar para la convergencia:
         - ``'%'``: Error relativo porcentual.
         - ``'/'``: Error relativo.
-        - ``'n'``: Número de cifras significativas.
+        - ``'n'``: Número de cifras significativas. εs = (0.5 * 10^(2-n))% [Scarborough, 1966]
+        - ``'t'``: Tolerancia. tol = |b - a|/2 (Solo aplica en los métodos cerrados)
 
     Methods
     -------
@@ -68,7 +69,7 @@ class Biseccion(Raices):
         max_iter: int
             Número máximo de iteraciones permitido.
         tipo_error: str
-            Tipo de error a utilizar: ``'%'``, ``'/'`` o ``'n'``.
+            Tipo de error a utilizar: ``'%'``, ``'/'``, ``'n'`` o ``'t'``.
         """
         super().__init__(f, x_min, x_max, tol, max_iter, tipo_error)
         self._calcular()
@@ -135,9 +136,11 @@ class Biseccion(Raices):
                 linea_base.set_xdata([self._tabla['x_min'][i], self._tabla['x_max'][i]])
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de la Bisección (tol= ' + str(self._tol) + '%)')
-        else:
+            plt.suptitle(r'Método de la Bisección ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
+        elif self._error_tolerancia:
             plt.suptitle('Método de la Bisección (tol= ' + str(self._tol) + ')')
+        else:
+            plt.suptitle(r'Método de la Bisección ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/brent.py

@@ -2,7 +2,6 @@ from mnspy.raíces import Raices
 import numpy as np
 import matplotlib.pyplot as plt
 import sys
-plt.rcParams.update(plt.rcParamsDefault)
 
 class Brent(Raices):
     """Clase para la implementación del cálculo de raíces por el método cerrado de Brent.
@@ -23,7 +22,8 @@ class Brent(Raices):
             Tipo de error a utilizar para la convergencia:
             - ``'%'``: Error relativo porcentual.
             - ``'/'``: Error relativo.
-            - ``'n'``: Número de cifras significativas.
+            - ``'n'``: Número de cifras significativas. εs = (0.5 * 10^(2-n))% [Scarborough, 1966]
+            - ``'t'``: Tolerancia. tol = |b - a|/2 (Solo aplica en los métodos cerrados)
 
         Methods
         -------
@@ -62,7 +62,7 @@ class Brent(Raices):
         max_iter: int
             Número máximo de iteraciones permitido.
         tipo_error: str
-            Tipo de error a utilizar: ``'%'``, ``'/'`` o ``'n'``.
+            Tipo de error a utilizar: ``'%'``, ``'/'``, ``'n'`` o ``'t'``.
         """
         # Inicialización de la clase padre
         super().__init__(f, x_min, x_max, tol, max_iter, tipo_error)
@@ -167,9 +167,11 @@ class Brent(Raices):
         """
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de Brent (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de la Brent ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
+        elif self._error_tolerancia:
+            plt.suptitle('Método de la Brent (tol= ' + str(self._tol) + ')')
         else:
-            plt.suptitle('Método de Brent (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de la Brent ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/falsa_posicion.py

@@ -2,7 +2,7 @@ from mnspy.raíces import Raices
 import numpy as np
 import matplotlib.pyplot as plt
 import sys
-plt.rcParams.update(plt.rcParamsDefault)
+
 
 class FalsaPosicion(Raices):
     """Clase para la implementación del cálculo de raíces por el método cerrado de la Falsa Posición.
@@ -23,7 +23,8 @@ class FalsaPosicion(Raices):
         Tipo de error a utilizar para la convergencia:
         - ``'%'``: Error relativo porcentual.
         - ``'/'``: Error relativo.
-        - ``'n'``: Número de cifras significativas.
+        - ``'n'``: Número de cifras significativas. εs = (0.5 * 10^(2-n))% [Scarborough, 1966]
+        - ``'t'``: Tolerancia. tol = |b - a|/2 (Solo aplica en los métodos cerrados)
 
     Methods
     -------
@@ -65,7 +66,7 @@ class FalsaPosicion(Raices):
         max_iter: int
             Número máximo de iteraciones permitido.
         tipo_error: str
-            Tipo de error a utilizar: ``'%'``, ``'/'`` o ``'n'``.
+            Tipo de error a utilizar: ``'%'``, ``'/'``, ``'n'`` o ``'t'``.
         """
         super().__init__(f, x_min, x_max, tol, max_iter, tipo_error)
         self._calcular()
@@ -127,9 +128,11 @@ class FalsaPosicion(Raices):
                 plt.plot([a, b], [self._f(a), self._f(b)], linestyle='dashed', c='purple', lw=1)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de la Falsa Posición (tol= ' + str(self._tol) + '%)')
-        else:
+            plt.suptitle(r'Método de la Falsa Posición ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
+        elif self._error_tolerancia:
             plt.suptitle('Método de la Falsa Posición (tol= ' + str(self._tol) + ')')
+        else:
+            plt.suptitle(r'Método de la Falsa Posición ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/muller.py

@@ -1,7 +1,7 @@
 from mnspy.raíces import Raices
 import numpy as np
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
+
 
 class Muller(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de Muller.
@@ -150,9 +150,9 @@ class Muller(Raices):
         plt.autoscale(True)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de Müller (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de Müller ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
-            plt.suptitle('Método de Müller (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de Müller ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/newton_raphson.py

@@ -1,6 +1,6 @@
 from mnspy.raíces import Raices
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
+
 
 class NewtonRaphson(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de Newton-Raphson.
@@ -155,9 +155,9 @@ class NewtonRaphson(Raices):
                 plt.plot([x_next, x_next], [0, self._f(x_next)], linestyle='dashed', c='purple', lw=1)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de Newton-Raphson (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de Newton-Raphson ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
-            plt.suptitle('Método de Newton-Raphson (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de Newton-Raphson ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/punto_fijo.py

@@ -1,7 +1,6 @@
 from mnspy.raíces import Raices
 import numpy as np
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
 
 class PuntoFijo(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de Newton-Raphson.
@@ -116,9 +115,9 @@ class PuntoFijo(Raices):
                 plt.plot([x, y], [y, y], linestyle='dashed', c='purple', lw=1)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de Punto Fijo (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de Punto Fijo ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
-            plt.suptitle('Método de Punto Fijo (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de Punto Fijo ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/raices.py

@@ -4,7 +4,6 @@ from mnspy.utilidades import es_notebook
 from tabulate import tabulate
 import math
 import sys
-plt.rcParams.update(plt.rcParamsDefault)
 
 class Raices:
     """
@@ -82,11 +81,13 @@ class Raices:
             Tipo de error a utilizar para la convergencia:
             - ``'%'``: Error relativo porcentual (por defecto).
             - ``'/'``: Error relativo.
-            - ``'n'``: Número de cifras significativas. εs = (0.5 * 10^(2-n)) %  (Scarborough, 1966)
+            - ``'n'``: Número de cifras significativas. εs = (0.5 * 10^(2-n))% [Scarborough, 1966]
+            - ``'t'``: Tolerancia. tol = |b - a|/2 (Solo aplica en los métodos cerrados)
         """
         self._f = f
         self._tol = tol
-        # tipo de error es '%' , '/' o 'n'
+        # tipo de error es '%' , '/' , 'n' ó 't'
+        self._error_tolerancia = False # Solo se puede usar en métodos cerrados
         match tipo_error:
             case "%":
                 self._error_porcentual = True
@@ -95,8 +96,11 @@ class Raices:
             case "n":
                 self._tol = 0.5 * 10 ** (2 - tol)
                 self._error_porcentual = True
+            case "t":
+                self._error_porcentual = False
+                self._error_tolerancia = True
             case _:
-                print("Tipo de error no valido, las opciones son: '%', '/', 'n'")
+                print("Tipo de error no valido, las opciones son: '%', '/', 'n', 't'")
                 sys.exit()
         self._max_iter = max_iter
         self._x_min = x_min
@@ -105,7 +109,7 @@ class Raices:
         self._x_0 = None
         self._x_1 = None
         self._tabla = {'x_min': [], 'x_max': [], 'x': [], 'Ea': []}
-        self._fmt = {'iter': 'd', 'x_l': '.5f', 'x_u': '.5f', 'x': '.10f', 'f': '.8f', 'E_a': '0.5%', 'E_t': '0.5%'}
+        self._fmt = {'iter': 'd', 'x_l': '.5f', 'x_u': '.5f', 'x': '.10f', 'f': '.8f', 'E_a': '0.5%', 'E_t': '0.5%' , 'tol': '0.8f'}
         self._converge = False
         self._rango = x_min, x_max
         plt.ioff()  # deshabilitada interactividad matplotlib
@@ -115,7 +119,7 @@ class Raices:
         Ajusta el formato de presentación de los datos en las tablas.
 
         Por defecto el formato es
-        {'iter': 'd', 'x_l': '.5f', 'x_u': '.5f', 'x': '.10f', 'f': '.8f', 'E_a': '0.5%', 'E_t': '0.5%'}
+        {'iter': 'd', 'x_l': '.5f', 'x_u': '.5f', 'x': '.10f', 'f': '.8f', 'E_a': '0.5%', 'E_t': '0.5%', 'tol': '0.8f'}
 
         Parameters
         ----------
@@ -128,8 +132,8 @@ class Raices:
         -------
         None
         """
-        if col == 'x_r' or col == 'x_i':
-            col = 'x'
+        # if col == 'x_r' or col == 'x_i':
+        #     col = 'x'
         self._fmt[col] = fmt
 
     def generar_tabla(self, valor_real: float = None, tablefmt=None):
@@ -160,41 +164,41 @@ class Raices:
         if self._x_min is not None:
             valores = np.array(
                 [self._tabla['x_min'], self._tabla['x_max'], self._tabla['x'], [self._f(val) for val in self._tabla['x']],
-                 self._tabla['Ea']]).transpose()
+                 self._tabla['Ea'], list(np.abs(np.array(self._tabla['x_max']) -np.array(self._tabla['x_min']))/2.0)]).transpose()
             if es_notebook() and (tablefmt is None or tablefmt in render_notebook):
                 if tablefmt is None:
                     tablefmt = 'html'
                 if valor_real is None:
                     return tabulate(valores, ['Iteración', '$x_{l}$', '$x_{u}$', '$x_{r}$', r'$f\left(x_{r}\right)$',
-                                              r'$\varepsilon_{a}$'], showindex=list(range(1, len(self._tabla['x']) + 1)),
+                                              r'$\varepsilon_{a}$', 'Tolerancia'], showindex=list(range(1, len(self._tabla['x']) + 1)),
                                     tablefmt=tablefmt, floatfmt=(
                             self._fmt['iter'], self._fmt['x_l'], self._fmt['x_u'], self._fmt['x'], self._fmt['f'],
-                            self._fmt['E_a']), colalign=("center",))
+                            self._fmt['E_a'], self._fmt['tol']), colalign=("center",))
                 else:
                     e_t = abs((np.array([self._tabla['x']]).transpose() - valor_real) / valor_real)
                     valores = np.hstack((valores, e_t))
                     return tabulate(valores, ['Iteración', '$x_{l}$', '$x_{u}$', '$x_{r}$', r'$f\left(x_{r}\right)$',
-                                              r'$\varepsilon_{a}$', r'$\varepsilon_{t}$'],
+                                              r'$\varepsilon_{a}$', 'Tolerancia' , r'$\varepsilon_{t}$'],
                                     showindex=list(range(1, len(self._tabla['x']) + 1)), tablefmt=tablefmt, floatfmt=(
                             self._fmt['iter'], self._fmt['x_l'], self._fmt['x_u'], self._fmt['x'], self._fmt['f'],
-                            self._fmt['E_a'], self._fmt['E_t']), colalign=("center",))
+                            self._fmt['E_a'], self._fmt['tol'], self._fmt['E_t']), colalign=("center",))
             else:
                 if tablefmt is None:
                     tablefmt = 'simple'
                 if valor_real is None:
-                    print(tabulate(valores, ['Iteración', 'x_l', 'x_u', 'x_r', 'f(x_r)', 'E_a'],
+                    print(tabulate(valores, ['Iteración', 'x_l', 'x_u', 'x_r', 'f(x_r)', 'E_a', 'tol'],
                                    showindex=list(range(1, len(self._tabla['x']) + 1)), tablefmt=tablefmt,
                                    floatfmt=(
-                                       self._fmt['iter'], self._fmt['x_l'], self._fmt['x_u'], self._fmt['x'], self._fmt['f'],
-                                       self._fmt['E_a']), colalign=("center",)))
+                                       self._fmt['iter'], self._fmt['x_l'], self._fmt['x_u'], self._fmt['x'], self._fmt['f'] ,
+                                       self._fmt['E_a'], self._fmt['tol']), colalign=("center",)))
                 else:
                     e_t = abs((np.array([self._tabla['x']]).transpose() - valor_real) / valor_real)
                     valores = np.hstack((valores, e_t))
-                    print(tabulate(valores, ['Iteración', 'x_l', 'x_u', 'x_r', 'f(x_r)', 'E_a', 'E_t'],
+                    print(tabulate(valores, ['Iteración', 'x_l', 'x_u', 'x_r', 'f(x_r)', 'E_a', 'tol','E_t'],
                                    showindex=list(range(1, len(self._tabla['x']) + 1)), tablefmt=tablefmt,
                                    floatfmt=(
                                        self._fmt['iter'], self._fmt['x_l'], self._fmt['x_u'], self._fmt['x'], self._fmt['f'],
-                                       self._fmt['E_a'], self._fmt['E_t']), colalign=("center",)))
+                                       self._fmt['E_a'], self._fmt['tol'], self._fmt['E_t']), colalign=("center",)))
         else:
             valores = np.array([self._tabla['x'], self._f(np.array(self._tabla['x'])), self._tabla['Ea']]).transpose()
             if es_notebook() and (tablefmt is None or tablefmt in render_notebook):
@@ -275,6 +279,16 @@ class Raices:
                     return False
             else:
                 return False
+        elif self._error_tolerancia:
+            if self._rango == (None, None):
+                print('El tipo de error ''t'' solo aplica a los métodos cerrados')
+                return False
+            else:
+                if abs(self._tabla['x_max'][-1]-self._tabla['x_min'][-1])/2.0 < self._tol:
+                    self._converge = True
+                    return True
+                else:
+                    return False
         else:
             lon = len(self._tabla['x'])
             if lon > 1:
@@ -370,6 +384,9 @@ class Raices:
         -------
         Tabla con los resultados finales de la iteración.
         """
+        if type(self) is Raices:  # Si la clase es Raíces, no tiene método asociado y solo sirve para graficar
+            print('No se generó solución')
+            return None
         if self._converge:
             if es_notebook():
                 valores = [['$x$:', self.x], ['$f(x)$:', self._f(self.x)],
@@ -400,6 +417,5 @@ def main():
     graf = Raices(z, 0, 5)
     graf.graficar()
 
-
 if __name__ == '__main__':
     main()

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/secante.py

@@ -1,7 +1,6 @@
 from mnspy.raíces import Raices
 import numpy as np
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
 
 class Secante(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de la Secante.
@@ -125,9 +124,9 @@ class Secante(Raices):
                     plt.plot([x_next, x_next], [0, self._f(x_next)], linestyle='dashed', c='purple', lw=1)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de la Secante (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de la Secante ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
-            plt.suptitle('Método de la Secante (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de la Secante ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/secante_modificada.py

@@ -1,6 +1,6 @@
 from mnspy.raíces import Raices
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
+
 
 class SecanteModificada(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de la Secante Modificada.
@@ -120,10 +120,10 @@ class SecanteModificada(Raices):
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
             plt.suptitle(
-                r'Método de la Secante Modificada, $\delta$ = ' + str(self._delta) + ' (tol= ' + str(self._tol) + '%)')
+                r'Método de la Secante Modificada, $\delta$ = ' + str(self._delta) + r' ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
             plt.suptitle(
-                r'Método de la Secante Modificada, $\delta$ = ' + str(self._delta) + ' (tol= ' + str(self._tol) + ')')
+                r'Método de la Secante Modificada, $\delta$ = ' + str(self._delta) + r' ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy/ra/303/255ces/wegstein.py

@@ -1,6 +1,5 @@
 from mnspy.raíces import Raices
 import matplotlib.pyplot as plt
-plt.rcParams.update(plt.rcParamsDefault)
 
 class Wegstein(Raices):
     """Clase para la implementación del cálculo de raíces por el método abierto de Wegstein.
@@ -132,9 +131,9 @@ class Wegstein(Raices):
                 plt.plot([x_next, x_next], [0, x_next], linestyle='dashed', c='purple', lw=1)
         plt.title(f'x = {self.x}')
         if self._error_porcentual:
-            plt.suptitle('Método de Wegstein (tol= ' + str(self._tol) + '%)')
+            plt.suptitle(r'Método de Wegstein ($\varepsilon_{s}[\%]$= ' + str(self._tol) + '%)')
         else:
-            plt.suptitle('Método de Wegstein (tol= ' + str(self._tol) + ')')
+            plt.suptitle(r'Método de Wegstein ($\varepsilon_{s}$= ' + str(self._tol) + ')')
         super().graficar(mostrar_sol, mostrar_iter, mostrar_lin_iter, n_puntos)
 
 

{mnspy-0.9.18 → mnspy-0.9.20}/mnspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnspy
-Version: 0.9.18
+Version: 0.9.20
 Summary: Paquete didáctico para métodos numéricos
 Home-page: https://github.com/EdwinSoft/mnspy
 Author: Edwin Córdoba

{mnspy-0.9.18 → mnspy-0.9.20}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name='mnspy',
-    version='0.9.18',
+    version='0.9.20',
     packages=['mnspy', 'mnspy.raíces', 'mnspy.derivada', 'mnspy.integrales', 'mnspy.interpolación',
               'mnspy.ecuaciones_algebraicas_lineales', 'mnspy.ecuaciones_diferenciales_ordinarias',
               'mnspy.ecuaciones_diferenciales_parciales', 'mnspy.ecuaciones_diferenciales_parciales.mdf',