mnspy 0.9.15__py3-none-any.whl → 0.9.17__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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.dist-info → mnspy-0.9.17.dist-info}/METADATA

@@ -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.dist-info → mnspy-0.9.17.dist-info}/RECORD

@@ -28,11 +28,11 @@ mnspy/ecuaciones_diferenciales_parciales/mef/__init__.py,sha256=-ZqVb1Pn4CGcUKL5
 mnspy/ecuaciones_diferenciales_parciales/mef/armadura.py,sha256=J0Og6NCSBLcwZCsb2_tzPdZAnUfLiSO-BZ82b86GC7Q,14761
 mnspy/ecuaciones_diferenciales_parciales/mef/barra.py,sha256=FB8dVdtRSMRAQYCjYgC8_yO8nShk8_uDBt5meHrAz9c,9867
 mnspy/ecuaciones_diferenciales_parciales/mef/ensamble.py,sha256=U6OrhxMubrmnIKkXyfTdM9UoQcAunTqRUcfxMGWtx30,105934
-mnspy/ecuaciones_diferenciales_parciales/mef/marco.py,sha256=60KMFmHB3fKd-W3Zdz4uZAQU42cYO_gV_0FzHjc1CcE,69041
+mnspy/ecuaciones_diferenciales_parciales/mef/marco.py,sha256=LGTZ--wfC3Bytp242aCX4iVQ4okD69tC04dIbaX8fJQ,70564
 mnspy/ecuaciones_diferenciales_parciales/mef/mef.py,sha256=SotSyqCblPRwcnzr1j0srKA60hKuPIzIWTjXSZu3nhw,43812
 mnspy/ecuaciones_diferenciales_parciales/mef/resorte.py,sha256=Jeq9bQjLfmIW0jkNA-ob6C27k5JGywZ1T9qLr4hMD0Q,13852
 mnspy/ecuaciones_diferenciales_parciales/mef/triangular_cst.py,sha256=nWK1uv9F9wpE_eelfhm1LyDiW7aMnckKf0mIcuhiY7U,12094
-mnspy/ecuaciones_diferenciales_parciales/mef/viga.py,sha256=-ys-041bJ0fSKrZ-cjyzfRzASMCCkTsSrw4145Mmo7c,41499
+mnspy/ecuaciones_diferenciales_parciales/mef/viga.py,sha256=-YNv-_XJabSmvSKGUREWhjClNd9Ip0QSa8zYNASF05s,42505
 mnspy/ecuaciones_diferenciales_parciales/mvf/__init__.py,sha256=TDanegLPvu7-F5UYKEFdDXhXUeptbYDzPcD7N3Ozd8s,1369
 mnspy/ecuaciones_diferenciales_parciales/mvf/mvf.py,sha256=nthYy1DeRYHEi3E_yX4GeEbAhZAdJAkZJzPEWwjkpfg,30053
 mnspy/ecuaciones_diferenciales_parciales/mvf/volumen_finito.py,sha256=cjIenv-mMDhfPXj0uL24G0Sm9WexWAane3ni8GXvoPc,32334
@@ -53,18 +53,18 @@ mnspy/interpolación/inter_spline_cubica.py,sha256=1oBT-t5zVB5RrLx6BkUWweKdwVwI_
 mnspy/interpolación/inter_spline_lineal.py,sha256=-UZUBcTLKIZqZw2ZZd2qIyxJK2Q4dqlZxRBdz-0jvuY,5196
 mnspy/interpolación/interpolacion.py,sha256=gV7OoLzGbN-p1L3vr-cXhoYd13vysVpLXpg8JujwfAc,1695
 mnspy/raíces/__init__.py,sha256=8_8u3bPEoHjh804bNVZVbNM2UOv-RiC7TmzCrz6zHCc,1497
-mnspy/raíces/bisección.py,sha256=PHXWJfZ5CZ2jZLlpTdZWjsOI6U_W6MH-HfQwAWZJ5yA,5682
-mnspy/raíces/brent.py,sha256=OisCG3poUL5m3XOPip6nARu50UTTSWzOr2JN_Qj8srU,7090
-mnspy/raíces/falsa_posicion.py,sha256=XMHdOr_VD4avticGWxFBr2GzVL0y-Qb0hHf7OAI_hwQ,5419
-mnspy/raíces/muller.py,sha256=xA77ltemBu-m7HFumazqPFbSpEBmffzfsZKZqzjclC0,6313
-mnspy/raíces/newton_raphson.py,sha256=S7DTVCxSwMr1l9YScM7B3dlemN1NIdJM74AaGJApChw,6442
-mnspy/raíces/punto_fijo.py,sha256=yGlx3PZ19s2ENtb515ytH1Vxw0Van_6-hyC2XRWLi4g,4711
-mnspy/raíces/raices.py,sha256=lTjSOk84sg1VdlElmHaZSRen00zpt0jNrnFBx_SStnU,17510
-mnspy/raíces/secante.py,sha256=t8-NcN-Ki8BYrh3Cf3VUjaaRLxz6qV1v5i8johKBlZs,5220
+mnspy/raíces/bisección.py,sha256=JHP8o48I58NWNAQwEDUfzotMTJsY4ZkyHaET_fd1AlE,5638
+mnspy/raíces/brent.py,sha256=RwGSRcAeFp-Qy8XMmcEU6UqEcNb0RP1UYdmVMMiXngs,6689
+mnspy/raíces/falsa_posicion.py,sha256=NAqgo9_U1XkWtUc9s9lcV4IpJ_-vxw_3b5p9pzDOQvs,5371
+mnspy/raíces/muller.py,sha256=XkXLk99TrW_0hYam5CrzrmSJi6fJx-KhhaRL7_xLzcs,5886
+mnspy/raíces/newton_raphson.py,sha256=HccOD0TZovQEzBi16Rcsg7gc7tvlrWPNplcpGDL6g04,6431
+mnspy/raíces/punto_fijo.py,sha256=XCRl-rUsuMkYy2baptXT_wPXBLGht-r2_qegAKwv8xo,4635
+mnspy/raíces/raices.py,sha256=GF6QTry--5piS5F2kw0gSnElNEBajdez-tZB8gQOkZM,17556
+mnspy/raíces/secante.py,sha256=mLYNV4dwy2BLveAlehSVdqiAlY0-ORT-tEDlWbjvs3Y,5082
 mnspy/raíces/secante_modificada.py,sha256=0bLgcG8K_O6Ras3vKBIQpUdDlB69tWKHbx_fE8-47SE,5105
 mnspy/raíces/wegstein.py,sha256=23HQ6QuelMNo8S8W1fzha8ozbcy_NdsjK5XLMaH-m38,5397
-mnspy-0.9.15.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-mnspy-0.9.15.dist-info/METADATA,sha256=PiLUJ3EW2mycuVYMxCmqOPok950hd2SUNq5KHnWota8,4641
-mnspy-0.9.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mnspy-0.9.15.dist-info/top_level.txt,sha256=fbooZdZwS41I8vFuAXnn5qL4_mfc1aPt_DM60ZpvtKE,6
-mnspy-0.9.15.dist-info/RECORD,,
+mnspy-0.9.17.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+mnspy-0.9.17.dist-info/METADATA,sha256=twCh69elQkudvd9rk65dmONJMOyh3pPgVVJRFAjE0tY,4641
+mnspy-0.9.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mnspy-0.9.17.dist-info/top_level.txt,sha256=fbooZdZwS41I8vFuAXnn5qL4_mfc1aPt_DM60ZpvtKE,6
+mnspy-0.9.17.dist-info/RECORD,,