mnspy 0.9.15__tar.gz → 0.9.17__tar.gz

{mnspy-0.9.15 → mnspy-0.9.17}/PKG-INFO

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

{mnspy-0.9.15 → mnspy-0.9.17}/mnspy/ecuaciones_diferenciales_parciales/mef/marco.py

@@ -215,28 +215,18 @@ class Marco(Elemento):
         # Esto se hace aplicando un momento corrector en el nodo i y las fuerzas
         # cortantes correspondientes en ambos nodos para mantener el equilibrio.
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en el extremo j (a liberar)
-            m_fem_j = -q * self._L ** 2 / 12
-            # Momento transferido al nodo i (carry-over) y fuerzas cortantes resultantes
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            # Aplicar correcciones a las fuerzas nodales globales
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            # La fuerza de momento en el nodo j se anula completamente.
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 12)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-q * self._L ** 2 / 12)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 12
+            self._fuerzas_j_rot[2, 0] -= -q * self._L ** 2 / 12
 
     def agregar_carga_trapezoidal(self, q_1: float, q_2: float):
         """Agrega una carga trapezoidalmente distribuida perpendicular al elemento.
@@ -273,25 +263,31 @@ class Marco(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en j (a liberar)
-            m_fem_j = -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                                                 2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
+            self._fuerzas_j_rot[2, 0] -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
 
     def agregar_carga_puntual(self, p: float, a: float = None):
         """Agrega una carga puntual perpendicular al elemento a una distancia 'a'.
@@ -332,24 +328,25 @@ class Marco(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -p * (self._L - a) * a ** 2 / self._L ** 2
-            m_corrector_i = -0.5 * m_fem_j
-            v_corrector = m_fem_j * 3.0 / (2.0 * self._L)
-
-            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * v_corrector
-            self._fuerzas_i_rot[0, 0] -= -self._s * v_corrector
-            self._nodo_i.grados_libertad['y'].fuerza -= self._c * v_corrector
-            self._fuerzas_i_rot[1, 0] -= self._c * v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza -= m_corrector_i
-            self._fuerzas_i_rot[2, 0] -= m_corrector_i
-
-            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -v_corrector
-            self._fuerzas_j_rot[0, 0] -= -self._s * -v_corrector
-            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -v_corrector
-            self._fuerzas_j_rot[1, 0] -= self._c * -v_corrector
-
-            self._nodo_j.grados_libertad['eje_z'].fuerza -= m_fem_j
-            self._fuerzas_j_rot[2, 0] -= m_fem_j
+            self._nodo_i.grados_libertad['x'].fuerza -= -self._s * (
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                                                                2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= -self._s * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['y'].fuerza -= self._c * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[1, 0] -= self._c * (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._fuerzas_i_rot[2, 0] -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._nodo_j.grados_libertad['x'].fuerza -= -self._s * -(
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -self._s * -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_j.grados_libertad['y'].fuerza -= self._c * -(
+                    -p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                                                                2.0 * self._L)
+            self._fuerzas_j_rot[1, 0] -= self._c * -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -p * (self._L - a) * a ** 2 / self._L ** 2
+            self._fuerzas_j_rot[2, 0] -= -p * (self._L - a) * a ** 2 / self._L ** 2
 
     def agregar_momento(self, m: float, a: float = None):
         m *= -1.0

{mnspy-0.9.15 → mnspy-0.9.17}/mnspy/ecuaciones_diferenciales_parciales/mef/viga.py

@@ -163,25 +163,14 @@ class Viga(Elemento):
         # Esto se hace aplicando un momento corrector y las fuerzas cortantes
         # correspondientes para mantener el equilibrio.
         if self._nodo_j.es_rotula:
-            # Momento de empotramiento en j (a liberar)
-            m_fem_j = -q * self._L ** 2 / 12
-            # Momento corrector para anular el momento en j
-            m_corrector = -m_fem_j
-            # Momento transferido al nodo i (carry-over)
-            m_carry_over_i = 0.5 * m_corrector
-            # Fuerzas cortantes de corrección
-            v_corrector = 1.5 * m_corrector / self._L
-
-            # Aplicar correcciones a las fuerzas nodales
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 12)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 12)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 12) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 12
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 12
 
     def agregar_carga_trapezoidal(self, q_1: float, q_2: float):
         """Agrega una carga trapezoidalmente distribuida."""
@@ -199,20 +188,19 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q_1 * self._L ** 2 / 12 - (
+                    q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(
+                    -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20) * 3.0 / (
+                    2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
+            self._fuerzas_j_rot[1, 0] -= -q_1 * self._L ** 2 / 12 - (q_2 - q_1) * self._L ** 2 / 20
 
     def agregar_carga_puntual(self, p: float, a: float = None):
         """Agrega una carga puntual perpendicular a una distancia 'a'."""
@@ -232,20 +220,16 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -p * (self._L - a) * a ** 2 / self._L ** 2
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-p * (self._L - a) * a ** 2 / self._L ** 2)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-p * (self._L - a) * a ** 2 / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -p * (self._L - a) * a ** 2 / self._L ** 2
+            self._fuerzas_j_rot[1, 0] -= -p * (self._L - a) * a ** 2 / self._L ** 2
 
     def agregar_momento(self, m: float, a: float = None):
         """Agrega un momento concentrado a una distancia 'a'."""
@@ -266,20 +250,16 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = m * a * (2 * self._L - 3 * a) / self._L ** 2
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
-            
-            self._nodo_j.grados_libertad['y'].fuerza -= v_corrector
-            self._fuerzas_j_rot[0, 0] -= v_corrector
-            self._nodo_j.grados_libertad['eje_z'].fuerza += m_corrector
-            self._fuerzas_j_rot[1, 0] += m_corrector
+            self._nodo_i.grados_libertad['y'].fuerza -= (m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (m * a * (2 * self._L - 3 * a) / self._L ** 2)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (m * a * (2 * self._L - 3 * a) / self._L ** 2)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (
+                    2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(m * a * (2 * self._L - 3 * a) / self._L ** 2) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= m * a * (2 * self._L - 3 * a) / self._L ** 2
+            self._fuerzas_j_rot[1, 0] -= m * a * (2 * self._L - 3 * a) / self._L ** 2
 
     def agregar_carga_triangular_descendente(self, q: float):
         """Agrega una carga triangular con valor máximo en el nodo i."""
@@ -296,15 +276,14 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q * self._L ** 2 / 30
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 30)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 30)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 30) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 30
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 30
 
     def agregar_carga_triangular_ascendente(self, q: float):
         """Agrega una carga triangular con valor máximo en el nodo j."""
@@ -321,15 +300,14 @@ class Viga(Elemento):
 
         # Corrección por rótula en el nodo j
         if self._nodo_j.es_rotula:
-            m_fem_j = -q * self._L ** 2 / 20
-            m_corrector = -m_fem_j
-            m_carry_over_i = 0.5 * m_corrector
-            v_corrector = 1.5 * m_corrector / self._L
-            
-            self._nodo_i.grados_libertad['y'].fuerza += v_corrector
-            self._fuerzas_i_rot[0, 0] += v_corrector
-            self._nodo_i.grados_libertad['eje_z'].fuerza += m_carry_over_i
-            self._fuerzas_i_rot[1, 0] += m_carry_over_i
+            self._nodo_i.grados_libertad['y'].fuerza -= (-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_i_rot[0, 0] -= (-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._nodo_i.grados_libertad['eje_z'].fuerza -= 0.5 * (-q * self._L ** 2 / 20)
+            self._fuerzas_i_rot[1, 0] -= 0.5 * (-q * self._L ** 2 / 20)
+            self._nodo_j.grados_libertad['y'].fuerza -= -(-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._fuerzas_j_rot[0, 0] -= -(-q * self._L ** 2 / 20) * 3.0 / (2.0 * self._L)
+            self._nodo_j.grados_libertad['eje_z'].fuerza -= -q * self._L ** 2 / 20
+            self._fuerzas_j_rot[1, 0] -= -q * self._L ** 2 / 20
 
     def _obtener_cargas(self) -> dict:
         return self._cargas

{mnspy-0.9.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/mnspy/ra/303/255ces/raices.py

@@ -82,7 +82,7 @@ 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)
         """
         self._f = f
         self._tol = tol

{mnspy-0.9.15 → mnspy-0.9.17}/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.15 → mnspy-0.9.17}/mnspy.egg-info/PKG-INFO

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

{mnspy-0.9.15 → mnspy-0.9.17}/setup.py

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