structsolve 0.3.0__tar.gz → 0.3.1__tar.gz

{structsolve-0.3.0 → structsolve-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.3.0
+Version: 0.3.1
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Requires-Python: >=3.8

{structsolve-0.3.0 → structsolve-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.3.0"
+version = "0.3.1"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = {text = "BSD-2-Clause"}
@@ -28,6 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: Unix",
 ]

{structsolve-0.3.0 → structsolve-0.3.1}/structsolve/freq.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import scipy
 from scipy.sparse.linalg import eigs, spsolve
@@ -9,8 +11,16 @@ from .sparseutils import remove_null_cols
 
 def _estimate_sigma(K, M):
     try:
-        x = np.random.RandomState(42).randn(K.shape[0])
-        y = spsolve(K, M @ x)
+        rhs = M @ np.random.RandomState(42).randn(K.shape[0])
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            y = spsolve(K, rhs)
+        if any(issubclass(w.category, (RuntimeWarning, Warning))
+               and "singular" in str(w.message).lower() for w in caught):
+            return -1.
+        residual = np.linalg.norm(K @ y - rhs)
+        if residual > 1e-6 * np.linalg.norm(rhs):
+            return -1.
         sigma = -abs((y @ K @ y) / (y @ M @ y))
         if not np.isfinite(sigma) or sigma == 0:
             return -1.
@@ -21,7 +31,7 @@ def _estimate_sigma(K, M):
 
 def freq(K, M, tol=0, sparse_solver=True,
         silent=False, sort=True, num_eigvalues=25,
-        num_eigvalues_print=5):
+        num_eigvalues_print=5, skip_null_cols=False):
     """Frequency Analysis
 
     Calculate the eigenvalues (`\lambda^2`) and mass-normalized eigenvectors
@@ -53,6 +63,9 @@ def freq(K, M, tol=0, sparse_solver=True,
         Number of calculated eigenvalues.
     num_eigvalues_print : int, optional
         Number of eigenvalues to print.
+    skip_null_cols : bool, optional
+        If True, skip the removal of null columns from the matrices.
+        Use only when K is known to be non-singular.
 
     Returns
     -------
@@ -67,10 +80,14 @@ def freq(K, M, tol=0, sparse_solver=True,
     msg('Eigenvalue solver... ', level=2, silent=silent)
 
     k = min(num_eigvalues, M.shape[0]-2)
-    if sparse_solver:
-        sizebkp = M.shape[0]
+    size = M.shape[0]
+    if skip_null_cols:
+        used_cols = None
+        Keff, Meff = K, M
+    else:
         Keff, Meff, used_cols = remove_null_cols(K, M, silent=silent,
                 level=3)
+    if sparse_solver:
         #NOTE Looking for better performance with symmetric matrices, I tried
         #     using sparseutils.sparse.is_symmetric and eigsh, but it seems not
         #     to improve speed (I did not try passing only half of the sparse
@@ -82,35 +99,30 @@ def freq(K, M, tol=0, sparse_solver=True,
         #NOTE eigs solves: [K] {u} = eigval [M] {u}
         #     therefore we must correct he sign of lambda^2 here:
         lambda2 = -eigvals
-        eigvecs = np.zeros((sizebkp, k), dtype=peigvecs.dtype)
-        eigvecs[used_cols, :] = peigvecs
     else:
-        msg('eig() solver...', level=3, silent=silent)
-        if isinstance(M, scipy.sparse.spmatrix):
-            Meff = M.toarray()
+        if isinstance(Meff, scipy.sparse.spmatrix):
+            Meff = Meff.toarray()
         else:
-            Meff = np.asarray(M)
-        if isinstance(K, scipy.sparse.spmatrix):
-            Keff = K.toarray()
+            Meff = np.asarray(Meff)
+        if isinstance(Keff, scipy.sparse.spmatrix):
+            Keff = Keff.toarray()
         else:
-            Keff = np.asarray(K)
-        sizebkp = Meff.shape[0]
-        col_sum = Meff.sum(axis=0)
-        check = col_sum != 0
-        used_cols = np.arange(Meff.shape[0])[check]
-        Meff = Meff[:, check][check, :]
-        Keff = Keff[:, check][check, :]
+            Keff = np.asarray(Keff)
 
         #TODO did not try using eigh when input is symmetric to see if there
         #     will be speed improvements
         # for effiency reasons, solving:
         #    [M]{u} = (-1/lambda2)[K]{u}
         #    [M]{u} = eigval [K]{u}
+        msg('eig() solver...', level=3, silent=silent)
         eigvals, peigvecs = eig(a=Meff, b=Keff)
         lambda2 = -1./eigvals
-        eigvecs = np.zeros((sizebkp, Keff.shape[0]),
-                           dtype=peigvecs.dtype)
-        eigvecs[check, :] = peigvecs
+
+    if used_cols is not None:
+        eigvecs = np.zeros((size, peigvecs.shape[1]), dtype=peigvecs.dtype)
+        eigvecs[used_cols, :] = peigvecs
+    else:
+        eigvecs = peigvecs
 
     msg('finished!', level=3, silent=silent)
 

{structsolve-0.3.0 → structsolve-0.3.1}/structsolve/linear_buckling.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 from scipy.sparse.linalg import eigsh, spsolve
 from scipy.linalg import eigh
@@ -8,8 +10,16 @@ from .sparseutils import remove_null_cols
 
 def _estimate_sigma(K, KG):
     try:
-        x = np.random.RandomState(42).randn(K.shape[0])
-        y = spsolve(K, KG @ x)
+        rhs = KG @ np.random.RandomState(42).randn(K.shape[0])
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            y = spsolve(K, rhs)
+        if any(issubclass(w.category, (RuntimeWarning, Warning))
+               and "singular" in str(w.message).lower() for w in caught):
+            return 1.
+        residual = np.linalg.norm(K @ y - rhs)
+        if residual > 1e-6 * np.linalg.norm(rhs):
+            return 1.
         sigma = abs((y @ KG @ y) / (y @ K @ y))
         if not np.isfinite(sigma) or sigma == 0:
             return 1.
@@ -18,7 +28,8 @@ def _estimate_sigma(K, KG):
         return 1.
 
 def lb(K, KG, tol=0, sparse_solver=True, silent=False,
-       num_eigvalues=25, num_eigvalues_print=5):
+       num_eigvalues=25, num_eigvalues_print=5,
+       skip_null_cols=False):
     """Linear Buckling Analysis
 
     It can also be used for more general eigenvalue analyzes if `K` is the
@@ -44,6 +55,9 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
         Number of calculated eigenvalues.
     num_eigvalues_print : int, optional
         Number of eigenvalues to print.
+    skip_null_cols : bool, optional
+        If True, skip the removal of null columns from the matrices.
+        Use only when K is known to be non-singular.
 
     Notes
     -----
@@ -57,38 +71,31 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
     msg('Eigenvalue solver... ', level=2, silent=silent)
 
     k = min(num_eigvalues, KG.shape[0]-2)
+    size = KG.shape[0]
+    if skip_null_cols:
+        used_cols = None
+    else:
+        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
     if sparse_solver:
         mode = 'cayley'
-        try:
-            sigma = _estimate_sigma(K, KG)
-            msg('eigsh() solver (sigma={0})...'.format(sigma), level=3, silent=silent)
-            eigvals, eigvecs = eigsh(A=KG, k=k,
-                    which='SM', M=K, tol=tol, sigma=sigma, mode=mode)
-            msg('finished!', level=3, silent=silent)
-        except Exception as e:
-            warn(str(e), level=4, silent=silent)
-            msg('aborted!', level=3, silent=silent)
-            sizebkp = KG.shape[0]
-            K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
-            sigma = _estimate_sigma(K, KG)
-            msg('eigsh() solver (sigma={0})...'.format(sigma), level=3, silent=silent)
-            eigvals, peigvecs = eigsh(A=KG, k=k,
-                    which='SM', M=K, tol=tol, sigma=sigma, mode=mode)
-            msg('finished!', level=3, silent=silent)
-            eigvecs = np.zeros((sizebkp, num_eigvalues),
-                               dtype=peigvecs.dtype)
-            eigvecs[used_cols, :] = peigvecs
+        sigma = _estimate_sigma(K, KG)
+        msg('eigsh() solver (sigma={0})...'.format(sigma), level=3, silent=silent)
+        eigvals, peigvecs = eigsh(A=KG, k=k,
+                which='SM', M=K, tol=tol, sigma=sigma, mode=mode)
+        msg('finished!', level=3, silent=silent)
 
     else:
-        size = KG.shape[0]
-        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
         K = K.toarray()
         KG = KG.toarray()
         msg('eigh() solver...', level=3, silent=silent)
         eigvals, peigvecs = eigh(a=KG, b=K)
         msg('finished!', level=3, silent=silent)
+
+    if used_cols is not None:
         eigvecs = np.zeros((size, num_eigvalues), dtype=peigvecs.dtype)
         eigvecs[used_cols, :] = peigvecs[:, :num_eigvalues]
+    else:
+        eigvecs = peigvecs[:, :num_eigvalues]
 
     eigvals = -1./eigvals
 

{structsolve-0.3.0 → structsolve-0.3.1}/structsolve.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.3.0
+Version: 0.3.1
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Requires-Python: >=3.8