mnspy 0.9.16__tar.gz → 0.9.19__tar.gz

mnspy-0.9.19/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.16 → mnspy-0.9.19}/PKG-INFO

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

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ecuaciones_diferenciales_parciales/mef/mef.py

@@ -178,9 +178,48 @@ class Nodo:
         self._tipo_soporte = []
 
     def get_soporte(self):
+        """Obtiene la información del tipo de soporte asignado al nodo.
+
+        Esta información solo se utiliza para la representación gráfica en el
+        diagrama de cargas y no afecta los cálculos del análisis estructural.
+
+        Returns
+        -------
+        list[int]
+            Una lista de dos elementos que define el tipo y estilo del soporte.
+        """
         return self._tipo_soporte
 
     def set_soporte(self, sop: list[int]):
+        """Establece el tipo de soporte para el nodo.
+
+        Esta asignación es puramente para fines de visualización en el diagrama
+        de cargas y no interviene en los cálculos de la matriz de rigidez ni
+        en la resolución del sistema.
+
+        Parameters
+        ----------
+        sop : list[int]
+            Una lista de dos enteros que define el soporte:
+            - ``sop[0]``: Tipo de Apoyo
+                - 0: Pivotado
+                - 1: Empotrado
+            - ``sop[1]``: Estilo del Apoyo
+                - Si Tipo Apoyo es 0 (Pivotado):
+                    - 0: inferior Móvil
+                    - 1: inferior Fijo
+                    - 2: superior Móvil
+                    - 3: superior Fijo
+                    - 4: izquierda Móvil
+                    - 5: izquierda Fijo
+                    - 6: derecha Móvil
+                    - 7: derecha Fijo
+                - Si Tipo Apoyo es 1 (Empotrado):
+                    - 0: fijo izquierdo
+                    - 1: fijo derecha
+                    - 2: fijo inferior
+                    - 3: fijo superior
+        """
         self._tipo_soporte = sop
 
     def agregar_fuerza_externa(self, carga: float, gl: str) -> None:

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/bisecci/303/263n.py

@@ -88,17 +88,15 @@ class Biseccion(Raices):
             print("La raíz no está dentro de este rango, pruebe con otro rango de datos")
             sys.exit()
 
-        # Bucle de iteración para evitar recursión profunda
-        while True:
-            self.x = (self._x_min + self._x_max) / 2
-
-            if self._fin_iteracion():
-                break  # Convergencia o máximo de iteraciones alcanzado
-
-            if np.sign(self._f(self._x_min)) == np.sign(self._f(self.x)):
-                self._x_min = self.x
-            else:
-                self._x_max = self.x
+        self.x = (self._x_min + self._x_max) / 2
+        if self._fin_iteracion():
+            return
+        elif np.sign(self._f(self._x_min)) == np.sign(self._f(self.x)):
+            self._x_min = self.x
+            self._calcular()
+        elif np.sign(self._f(self._x_max)) == np.sign(self._f(self.x)):
+            self._x_max = self.x
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/brent.py

@@ -99,53 +99,48 @@ class Brent(Raices):
                 "signos diferentes")
             sys.exit()
 
-        # Bucle de iteración para evitar recursión profunda
-        while True:
-            x_a, x_b, x_c = self._val
-            y_a, y_b, y_c = self._val_f
-            x_d = 0  # No se usa en la lógica actual, pero se mantiene por si se reimplementa una condición
-
-            self._x_min = min([x_a, x_b])
-            self._x_max = max([x_a, x_b])
-
-            if len(self._val_f) == len(set(self._val_f)):
-                # Si los valores de y son distintos, se usa interpolación cuadrática inversa
-                self.x = (x_a * y_b * y_c / ((y_a - y_b) * (y_a - y_c)) +
-                          x_b * y_a * y_c / ((y_b - y_a) * (y_b - y_c)) +
-                          x_c * y_a * y_b / ((y_c - y_a) * (y_c - y_b)))
-            else:
-                # Si hay valores de y repetidos, se usa el método de la secante (falsa posición)
-                self.x = (y_a * x_b - y_b * x_a) / (y_a - y_b)
-
-            # Se verifica si el paso de interpolación es aceptable, si no, se usa bisección
-            cond1 = (self.x - (3 * x_a + x_b) / 4) * (self.x - x_b) >= 0
-            cond2 = self._biseccion_usada and abs(self.x - x_b) >= abs(x_b - x_c) / 2
-            cond3 = not self._biseccion_usada and abs(self.x - x_b) >= abs(x_c - x_d) / 2
-
-            if cond1 or cond2 or cond3:
-                self.x = (x_a + x_b) / 2
-                self._biseccion_usada = True
-            else:
-                self._biseccion_usada = False
-
-            if self._fin_iteracion():
-                break
-
-            y_x = self._f(self.x)
-            x_c, y_c = x_b, y_b # Actualizar el punto previo
-
-            if np.sign(y_a) == np.sign(y_x):
-                x_a, y_a = self.x, y_x
-            else:
-                x_b, y_b = self.x, y_x
-
-            # Se asegura de nuevo que |f(a)| > |f(b)| para la siguiente iteración
-            if abs(y_a) < abs(y_b):
-                x_a, x_b = x_b, x_a
-                y_a, y_b = y_b, y_a
-
-            self._val = x_a, x_b, x_c
-            self._val_f = y_a, y_b, y_c
+        x_a, x_b, x_c = self._val
+        y_a, y_b, y_c = self._val_f
+        x_d = 0
+        self._x_min = min([x_a, x_b])
+        self._x_max = max([x_a, x_b])
+        if len(self._val_f) == len(set(self._val_f)):
+            # si los y son diferentes se usa el método de la cuadrática inversa
+            self.x = x_a * y_b * y_c / ((y_a - y_b) * (y_a - y_c)) + x_b * y_a * y_c / (
+                    (y_b - y_a) * (y_b - y_c)) + x_c * y_a * y_b / ((y_c - y_a) * (y_c - y_b))
+        else:
+            # Se usa el método de la falsa posición
+            self.x = (y_a * x_b - y_b * x_a) / (y_a - y_b)
+        if (self.x - (3 * x_a + x_b) / 4) * (self.x - x_b) >= 0 or (
+                self._biseccion_usada and abs(self.x - x_b) >= abs(x_b - x_c) / 2) or (
+                not self._biseccion_usada and abs(self.x - x_b) >= abs(x_c - x_d) / 2):
+            self.x = (x_a + x_b) / 2
+            self._biseccion_usada = True
+        else:
+            self._biseccion_usada = False
+        y_x = self._f(self.x)
+        # x_d = x_c     # TODO Revisar el código esta variable porque no se usa
+        x_c = x_b
+        y_c = y_b
+        if np.sign(y_a) == np.sign(y_x):
+            x_a = self.x
+            y_a = y_x
+        else:
+            x_b = self.x
+            y_b = y_x
+        if abs(y_a) < abs(y_b):
+            x_t = x_a
+            y_t = y_a
+            x_a = x_b
+            y_a = y_b
+            x_b = x_t
+            y_b = y_t
+        self._val = x_a, x_b, x_c
+        self._val_f = y_a, y_b, y_c
+        if self._fin_iteracion():
+            return
+        else:
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = False,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/falsa_posicion.py

@@ -86,18 +86,16 @@ class FalsaPosicion(Raices):
             print("La raíz no está dentro de este rango, pruebe con otro rango de datos")
             sys.exit()
 
-        # Bucle de iteración para evitar recursión profunda
-        while True:
-            self.x = self._x_max - (self._f(self._x_max) * (self._x_min - self._x_max)) / (
-                    self._f(self._x_min) - self._f(self._x_max))
-
-            if self._fin_iteracion():
-                break  # Convergencia o máximo de iteraciones alcanzado
-
-            if np.sign(self._f(self._x_min)) == np.sign(self._f(self.x)):
-                self._x_min = self.x
-            else:
-                self._x_max = self.x
+        self.x = self._x_max - (self._f(self._x_max) * (self._x_min - self._x_max)) / (
+                self._f(self._x_min) - self._f(self._x_max))
+        if self._fin_iteracion():
+            return
+        elif np.sign(self._f(self._x_min)) == np.sign(self._f(self.x)):
+            self._x_min = self.x
+            self._calcular()
+        elif np.sign(self._f(self._x_max)) == np.sign(self._f(self.x)):
+            self._x_max = self.x
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/muller.py

@@ -88,40 +88,34 @@ class Muller(Raices):
         -------
         None
         """
-        # Bucle de iteración para evitar recursión profunda
-        while True:
-            h_0 = self._x_1_i - self._x_0_i
-            h_1 = self._x_2_i - self._x_1_i
-            d_0 = (self._f(self._x_1_i) - self._f(self._x_0_i)) / h_0
-            d_1 = (self._f(self._x_2_i) - self._f(self._x_1_i)) / h_1
-
-            # Coeficientes de la parábola a*x^2 + b*x + c
-            a = (d_1 - d_0) / (h_1 + h_0)
-            b = a * h_1 + d_1
-            c = self._f(self._x_2_i)
-
-            # Guardar coeficientes para graficar
-            self._a_2.append(a)
-            self._a_1.append(d_0)
-            self._a_0.append(self._f(self._x_0_i))
-            self._list_x_0.append(self._x_0_i)
-            self._list_x_1.append(self._x_1_i)
-            self._list_x_2.append(self._x_2_i)
-
-            # Fórmula cuadrática, se elige el denominador más grande para evitar restas catastróficas.
-            rad = np.sqrt(b ** 2 - 4 * a * c)
-            if abs(b + rad) > abs(b - rad):
-                den = b + rad
-            else:
-                den = b - rad
-
-            self.x = self._x_2_i - (2 * c / den)
-
-            if self._fin_iteracion():
-                break  # Convergencia o máximo de iteraciones alcanzado
-
-            # Actualizar los puntos para la siguiente iteración
-            self._x_0_i, self._x_1_i, self._x_2_i = self._x_1_i, self._x_2_i, self.x
+        h_0 = self._x_1_i - self._x_0_i
+        h_1 = self._x_2_i - self._x_1_i
+        d_0 = (self._f(self._x_1_i) - self._f(self._x_0_i)) / h_0
+        d_1 = (self._f(self._x_2_i) - self._f(self._x_1_i)) / h_1
+        a = (d_1 - d_0) / (h_1 + h_0)
+        b = a * h_1 + d_1
+        c = self._f(self._x_2_i)
+        # ***
+        self._a_2 += [a]
+        self._a_1 += [d_0]
+        self._a_0 += [self._f(self._x_0_i)]
+        self._list_x_0 += [self._x_0_i]
+        self._list_x_1 += [self._x_1_i]
+        self._list_x_2 += [self._x_2_i]
+        # ***
+        rad = np.sqrt(b ** 2 - 4 * a * c)
+        if abs(b + rad) > abs(b - rad):
+            den = b + rad
+        else:
+            den = b - rad
+        self.x = self._x_2_i - 2 * c / den
+        if self._fin_iteracion():
+            return
+        else:
+            self._x_0_i = self._x_1_i
+            self._x_1_i = self._x_2_i
+            self._x_2_i = self.x
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/newton_raphson.py

@@ -117,9 +117,11 @@ class NewtonRaphson(Raices):
         -------
         None
         """
-        # Bucle de iteración para evitar recursión profunda
-        while not self._fin_iteracion():
-            self.x -= self._f(self.x) / self._df(self.x)
+        self.x -= self._f(self.x) / self._df(self.x)
+        if self._fin_iteracion():
+            return
+        else:
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/punto_fijo.py

@@ -74,10 +74,11 @@ class PuntoFijo(Raices):
         -------
         None
         """
-        # Bucle de iteración para evitar recursión profunda
-        while not self._fin_iteracion():
-            # self.x = self._f(self.x) # La función f es en realidad g(x)
-            self.x = self._f(self.x)
+        self.x += self._f(self.x) - self.x
+        if self._fin_iteracion():
+            return
+        else:
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/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.
+            - ``'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.16 → mnspy-0.9.19}/mnspy/ra/303/255ces/secante.py

@@ -80,13 +80,14 @@ class Secante(Raices):
         -------
         None
         """
-        # Bucle de iteración para evitar recursión profunda
-        while not self._fin_iteracion():
-            # Fórmula del método de la secante
-            self.x = self._x_1_i - (self._f(self._x_1_i) * (self._x_1_i - self._x_0_i)) / (
-                    self._f(self._x_1_i) - self._f(self._x_0_i))
-            # Actualizar los puntos para la siguiente iteración
-            self._x_0_i, self._x_1_i = self._x_1_i, self.x
+        self.x -= (self._f(self._x_1_i) * (self._x_1_i - self._x_0_i)) / (
+                self._f(self._x_1_i) - self._f(self._x_0_i))
+        self._x_0_i = self._x_1_i
+        self._x_1_i = self.x
+        if self._fin_iteracion():
+            return
+        else:
+            self._calcular()
 
     def graficar(self, mostrar_sol: bool = True, mostrar_iter: bool = True, mostrar_lin_iter: bool = True,
                  n_puntos: int = 100):

{mnspy-0.9.16 → mnspy-0.9.19}/mnspy.egg-info/PKG-INFO

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

{mnspy-0.9.16 → mnspy-0.9.19}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name='mnspy',
-    version='0.9.16',
+    version='0.9.19',
     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',