pyMOTO 1.5.0__py3-none-any.whl → 1.5.1b1__py3-none-any.whl

pymoto/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.5.0'
+__version__ = '1.5.1-beta1'
 
 from .common.domain import DomainDefinition
 

pymoto/common/domain.py

@@ -91,6 +91,7 @@ class DomainDefinition:
         if self.nelz is None:
             self.nelz = 0
         self.unitx, self.unity, self.unitz = unitx, unity, unitz
+        self.origin = np.array([0.0, 0.0, 0.0])
 
         self.dim = 1 if (self.nelz == 0 and self.nely == 0) else (2 if self.nelz == 0 else 3)
 
@@ -287,7 +288,7 @@ class DomainDefinition:
             patch.set_path(self.get_path(x + u, y + v))
 
     # flake8: noqa: C901
-    def write_to_vti(self, vectors: dict, filename="out.vti", scale=1.0, origin=(0.0, 0.0, 0.0)):
+    def write_to_vti(self, vectors: dict, filename="out.vti", scale=1.0):
         """ Write all given vectors to a Paraview (VTI) file
 
         The size of the vectors should be a multiple of ``nel`` or ``nnodes``. Based on their size they are marked as
@@ -299,7 +300,6 @@ class DomainDefinition:
             vectors: A dictionary of vectors to write. Keys are used as vector names.
             filename (str): The file loction
             scale: Uniform scaling of the gridpoints
-            origin: Origin of the domain
         """
         ext = '.vti'
         if ext not in os.path.splitext(filename)[-1].lower():
@@ -336,7 +336,7 @@ class DomainDefinition:
             file.write(f"<ImageData WholeExtent=\"0 {self.nelx} 0 {self.nely} 0 {self.nelz}\"".encode())
 
             # Origin of domain
-            file.write(f" Origin=\"{origin[0]*scale} {origin[1]*scale} {origin[2]*scale}\"".encode())
+            file.write(f" Origin=\"{self.origin[0]*scale} {self.origin[1]*scale} {self.origin[2]*scale}\"".encode())
 
             # Spacing of points (dx, dy, dz)
             dx, dy, dz = self.element_size[0:3]*scale

pymoto/common/dyadcarrier.py

@@ -393,7 +393,7 @@ class DyadCarrier(object):
         exprvars = (rowvar, colvar) if mat is None else (rowvar, matvar, colvar)
         expr = ','.join(exprvars) + '->' + batchvar
 
-        val = 0.0 if batchsize is None else np.zeros(batchsize)
+        val = 0.0 if batchsize is None else np.zeros(batchsize, dtype=np.result_type(mat, self.dtype))
         for ui, vi in zip(self.u, self.v):
             uarg = ui if rows is None else ui[rows]
             varg = vi if cols is None else vi[cols]

pymoto/common/mma.py

@@ -305,8 +305,12 @@ class MMA:
 
         # Setting up for constriants
         self.m = len(self.responses) - 1
-        self.a = np.zeros(self.m)
-        self.c = self.cCoef * np.ones(self.m)
+        self.a = kwargs.get("a", np.zeros(self.m))
+        if len(self.a) != self.m:
+            raise RuntimeError(f"Length of the a vector ({len(self.a)}) should be equal to # constraints ({self.m}).")
+        self.c = kwargs.get("c", np.full(self.m, self.cCoef, dtype=float))
+        if len(self.c) != self.m:
+            raise RuntimeError(f"Length of the c vector ({len(self.c)}) should be equal to # constraints ({self.m}).")
         self.d = np.ones(self.m)
         self.gold1 = np.zeros(self.m + 1)
         self.gold2 = self.gold1.copy()
@@ -371,11 +375,15 @@ class MMA:
             # Calculate response
             self.funbl.response()
 
+            xval, _ = _concatenate_to_array([s.state for s in self.variables])
+
             # Save response
             f = ()
             for s in self.responses:
                 if np.size(s.state) != 1:
                     raise TypeError("State of responses must be scalar.")
+                if np.iscomplexobj(s.state):
+                    raise TypeError("Responses must be real-valued.")
                 f += (s.state, )
 
             # Check function change convergence criterion
@@ -564,4 +572,4 @@ class MMA:
             print(f"  | Changes: {', '.join(change_msgs)}")
 
         return xmma, change
-      
+      

pymoto/core_objects.py

@@ -5,6 +5,7 @@ import time
 import copy
 from typing import Union, List, Any
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from .utils import _parse_to_list, _concatenate_to_array, _split_from_array
 
 
@@ -186,14 +187,14 @@ class SignalSlice(Signal):
     The sliced values are referenced to their original source Signal, such that they can be used and updated in modules.
     This means that updating the values in this SignalSlice changes the data in its source Signal.
     """
-    def __init__(self, orig_signal, sl, tag=None):
-        self.orig_signal = orig_signal
+    def __init__(self, base, sl, tag=None):
+        self.base = base
         self.slice = sl
         self.keep_alloc = False  # Allocation must be False because sensitivity cannot be assigned with [] operator
 
         # for s in slice:
         if tag is None:
-            self.tag = f"{self.orig_signal.tag}[{fmt_slice(self.slice)}]"
+            self.tag = f"{self.base.tag}[{fmt_slice(self.slice)}]"
         else:
             self.tag = tag
 
@@ -203,7 +204,7 @@ class SignalSlice(Signal):
     @property
     def state(self):
         try:
-            return None if self.orig_signal.state is None else self.orig_signal.state[self.slice]
+            return None if self.base.state is None else self.base.state[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (getter). Signal details:" +
@@ -212,7 +213,7 @@ class SignalSlice(Signal):
     @state.setter
     def state(self, new_state):
         try:
-            self.orig_signal.state[self.slice] = new_state
+            self.base.state[self.slice] = new_state
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (setter). Signal details:" +
@@ -221,7 +222,7 @@ class SignalSlice(Signal):
     @property
     def sensitivity(self):
         try:
-            return None if self.orig_signal.sensitivity is None else self.orig_signal.sensitivity[self.slice]
+            return None if self.base.sensitivity is None else self.base.sensitivity[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.sensitivity (getter). Signal details:" +
@@ -230,26 +231,55 @@ class SignalSlice(Signal):
     @sensitivity.setter
     def sensitivity(self, new_sens):
         try:
-            if self.orig_signal.sensitivity is None:
+            if self.base.sensitivity is None:
+                # Initialize sensitivity of base-signal
                 if new_sens is None:
                     return  # Sensitivity doesn't need to be initialized when it is set to None
                 try:
-                    self.orig_signal.sensitivity = self.orig_signal.state * 0  # Make a new copy with 0 values
+                    self.base.sensitivity = self.base.state * 0  # Make a new copy with 0 values
                 except TypeError:
-                    if self.orig_signal.state is None:
+                    if self.base.state is None:
                         raise TypeError("Could not initialize sensitivity because state is not set" + self._err_str())
                     else:
-                        raise TypeError(f"Could not initialize sensitivity for type \'{type(self.orig_signal.state).__name__}\'")
+                        raise TypeError(f"Could not initialize sensitivity for type \'{type(self.base.state).__name__}\'")
 
             if new_sens is None:
                 new_sens = 0  # reset() uses this
 
-            self.orig_signal.sensitivity[self.slice] = new_sens
+            self.base.sensitivity[self.slice] = new_sens
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (setter). Signal details:" +
                           self._err_str()).with_traceback(sys.exc_info()[2])
 
+    def add_sensitivity(self, ds: Any):
+        """ Add a new term to internal sensitivity """
+        try:
+            if ds is None:
+                return
+            if self.base.sensitivity is None:
+                self.base.sensitivity = self.base.state * 0
+                # self.sensitivity = copy.deepcopy(ds)
+
+            if hasattr(self.sensitivity, "add_sensitivity"):
+                # Allow user to implement a custom add_sensitivity function instead of __iadd__
+                self.sensitivity.add_sensitivity(ds)
+            else:
+                self.sensitivity += ds
+            return self
+        except TypeError:
+            if isinstance(ds, type(self.sensitivity)):
+                raise TypeError(
+                    f"Cannot add to the sensitivity with type '{type(self.sensitivity).__name__}'" + self._err_str())
+            else:
+                raise TypeError(
+                    f"Adding wrong type '{type(ds).__name__}' to the sensitivity '{type(self.sensitivity).__name__}'" + self._err_str())
+        except ValueError:
+            sens_shape = self.sensitivity.shape if hasattr(self.sensitivity, 'shape') else ()
+            ds_shape = ds.shape if hasattr(ds, 'shape') else ()
+            raise ValueError(
+                f"Cannot add argument of shape {ds_shape} to the sensitivity of shape {sens_shape}" + self._err_str()) from None
+
     def reset(self, keep_alloc: bool = None):
         """ Reset the sensitivities to zero or None
         This must be called to clear internal memory of subsequent sensitivity calculations.
@@ -296,30 +326,54 @@ def _is_valid_module(mod: Any):
     return False
 
 
-def _check_function_signature(fn, signals):
+# Type definition for bound method
+class BoundMethod:
+    __self__: object
+
+
+BoundMethodT = Union[Callable, BoundMethod]
+
+
+def _check_function_signature(fn: BoundMethodT, signals: list = None) -> (int, int):
     """ Checks the function signature against given signal list
-    :param fn: response_ or sensitivity_ function of a Module
-    :param signals: The signals involved
+
+    - Only positional-only or positional-or-keyword arguments are allowed
+      (https://peps.python.org/pep-0362/#parameter-object)
+    - If `signals` is provided, the number of them is compared with the allowed min/max number of arguments
+
+    Args:
+        fn: response_ or sensitivity_ function of a Module
+        signals (optional): The signals involved, which are checked with the function signature
+
+    Returns:
+        (min_args, max_args): Minimum and maximum number of accepted arguments to the function;
+          `None` denotes an unlimited number of maximum arguments (caused by `*args`)
     """
     min_args, max_args = 0, 0
     callstr = f"{type(fn.__self__).__name__}.{fn.__name__}{inspect.signature(fn)}"
+    # Loop over all the parameters defined for the function
     for s, p in inspect.signature(fn).parameters.items():
         if p.kind == inspect.Parameter.POSITIONAL_ONLY or p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
-            if p.default != inspect.Parameter.empty:
-                raise SyntaxError(f"{callstr} must not have default values \"{p}\"")
-            min_args += 1
-            if max_args >= 0:
+            if p.default == inspect.Parameter.empty:
+                # No default argument is provided, a value MUST be provided
+                min_args += 1
+            if max_args is not None:
                 max_args += 1
         elif p.kind == inspect.Parameter.VAR_POSITIONAL:
-            max_args = -1
+            # If *args is passed, the maximum number of arguments is unknown. Does not affect minimum number
+            max_args = None
         elif p.kind == inspect.Parameter.KEYWORD_ONLY:
-            raise SyntaxError(f"{callstr} may not contain keyword arguments \"{p}\"")
+            raise SyntaxError(f"{callstr} may not contain keyword-only arguments \"{p}\"")
         elif p.kind == inspect.Parameter.VAR_KEYWORD:
-            raise SyntaxError(f"{callstr} may not contain \"{p}\"")
-    if len(signals) < min_args:
-        raise TypeError(f"Not enough arguments ({len(signals)}) for {callstr}")
-    if max_args >= 0 and len(signals) > max_args:
-        raise TypeError(f"Too many arguments ({len(signals)}) for {callstr}")
+            raise SyntaxError(f"{callstr} may not contain dict of keyword-only arguments \"{p}\"")
+
+    # Check with signal list
+    if signals is not None:
+        if len(signals) < min_args:
+            raise TypeError(f"Not enough arguments ({len(signals)}) for {callstr}; expected {min_args}")
+        if max_args is not None and len(signals) > max_args:
+            raise TypeError(f"Too many arguments ({len(signals)}) for {callstr}; expected {max_args}")
+    return min_args, max_args
 
 
 class RegisteredClass(object):
@@ -408,7 +462,7 @@ class Module(ABC, RegisteredClass):
     >> Module([inputs])
 
     Using keywords:
-    >> Module(sig_in=[inputs], sig_out=[outputs]
+    >> Module(sig_in=[inputs], sig_out=[outputs])
     """
 
     def _err_str(self, module_signature: bool = True, init: bool = True, fn=None):
@@ -493,8 +547,12 @@ class Module(ABC, RegisteredClass):
             raise type(e)(str(e) + "\n\t| Above error was raised when calling response(). Module details:" +
                           self._err_str(fn=self._response)).with_traceback(sys.exc_info()[2])
 
-    def __call__(self):
-        return self.response()
+    def __call__(self, *args):
+        if len(args) == 0 and len(self.sig_in) > 0:
+            inp = [s.state for s in self.sig_in]
+            return self._response(*inp)
+        else:
+            return self._response(*args)
 
     def sensitivity(self):
         """  Calculate sensitivities using backpropagation
@@ -556,67 +614,74 @@ class Module(ABC, RegisteredClass):
 class Network(Module):
     """ Binds multiple Modules together as one Module
 
+    Initialize a network with a number of modules that should be executed consecutively
     >> Network(module1, module2, ...)
 
     >> Network([module1, module2, ...])
 
     >> Network((module1, module2, ...))
 
+    Modules can also be constructed using a dictionary based on strings
     >> Network([ {type="module1", sig_in=[sig1, sig2], sig_out=[sig3]},
                  {type="module2", sig_in=[sig3], sig_out=[sig4]} ])
 
+    Appending modules to a network will output the signals automatically
+    >> fn = Network()
+    >> s_out = fn.append(module1)
+
+    Args:
+        print_timing: Print timing of each module inside this Network
     """
     def __init__(self, *args, print_timing=False):
+        super().__init__()
         self._init_loc = get_init_str()
-
-        # Obtain the internal blocks
-        self.mods = _parse_to_list(*args)
-
-        # Check if the blocks are initialized, else create them
-        for i, b in enumerate(self.mods):
-            if isinstance(b, dict):
-                exclude_keys = ['type']
-                b_ex = {k: b[k] for k in set(list(b.keys())) - set(exclude_keys)}
-                self.mods[i] = Module.create(b['type'], **b_ex)
-
-        # Check validity of modules
-        for m in self.mods:
-            if not _is_valid_module(m):
-                raise TypeError(f"Argument is not a valid Module, type=\'{type(mod).__name__}\'.")
-
-        # Gather all the input and output signals of the internal blocks
-        all_in = set()
-        all_out = set()
-        [all_in.update(b.sig_in) for b in self.mods]
-        [all_out.update(b.sig_out) for b in self.mods]
-        in_unique = all_in - all_out
-
-        # Initialize the parent module, with correct inputs and outputs
-        super().__init__(list(in_unique), list(all_out))
-
+        self.mods = []  # Empty module list
+        self.append(*args)  # Append to module list
         self.print_timing = print_timing
 
-    def timefn(self, fn, prefix='Evaluation'):
+    def timefn(self, fn, name=None):
         start_t = time.time()
         fn()
         duration = time.time() - start_t
-        if duration > .5:
-            print(f"{prefix} {fn} took {time.time() - start_t} s")
+        if name is None:
+            name = f"{fn}"
+        if isinstance(self.print_timing, bool):
+            tmin = 0.0
+        else:
+            tmin = self.print_timing
+        if duration > tmin:
+            print(f"{name} took {time.time() - start_t} s")
 
     def response(self):
-        if self.print_timing:
-            [self.timefn(b.response, prefix='Response') for b in self.mods]
+        if self.print_timing is not False:
+            start_t = time.time()
+            [self.timefn(m.response, name=f"-- Response of \"{type(m).__name__}\"") for m in self.mods]
+            duration = time.time() - start_t
+            if isinstance(self.print_timing, bool):
+                tmin = 0.0
+            else:
+                tmin = self.print_timing
+            if duration > tmin:
+                print(f"-- TOTAL Response took {time.time() - start_t} s")
         else:
-            [b.response() for b in self.mods]
+            [m.response() for m in self.mods]
 
     def sensitivity(self):
-        if self.print_timing:
-            [self.timefn(b.sensitivity, 'Sensitivity') for b in reversed(self.mods)]
+        if self.print_timing is not False:
+            start_t = time.time()
+            [self.timefn(m.sensitivity, name=f"-- Sensitivity of \"{type(m).__name__}\"") for m in reversed(self.mods)]
+            duration = time.time() - start_t
+            if isinstance(self.print_timing, bool):
+                tmin = 0.0
+            else:
+                tmin = self.print_timing
+            if duration > tmin:
+                print(f"-- TOTAL Sensitivity took {time.time() - start_t} s")
         else:
-            [b.sensitivity() for b in reversed(self.mods)]
+            [m.sensitivity() for m in reversed(self.mods)]
 
     def reset(self):
-        [b.reset() for b in reversed(self.mods)]
+        [m.reset() for m in reversed(self.mods)]
 
     def _response(self, *args):
         pass  # Unused
@@ -636,13 +701,25 @@ class Network(Module):
     def __iter__(self):
         return iter(self.mods)
 
+    def __call__(self, *args):
+        return self.append(*args)
+
     def append(self, *newmods):
         modlist = _parse_to_list(*newmods)
+        if len(modlist) == 0:
+            return
 
         # Check if the blocks are initialized, else create them
+        for i, m in enumerate(modlist):
+            if isinstance(m, dict):
+                exclude_keys = ['type']
+                b_ex = {k: m[k] for k in set(list(m.keys())) - set(exclude_keys)}
+                modlist[i] = Module.create(m['type'], **b_ex)
+
+        # Check validity of modules
         for i, m in enumerate(modlist):
             if not _is_valid_module(m):
-                raise TypeError(f"Argument #{i} is not a valid module, type=\'{type(mod).__name__}\'.")
+                raise TypeError(f"Argument #{i} is not a valid module, type=\'{type(m).__name__}\'.")
 
         # Obtain the internal blocks
         self.mods.extend(modlist)
@@ -657,4 +734,4 @@ class Network(Module):
         self.sig_in = _parse_to_list(in_unique)
         self.sig_out = _parse_to_list(all_out)
 
-        return modlist[-1].sig_out[0] if len(modlist[-1].sig_out) == 1 else modlist[-1].sig_out  # Returns the output signal
+        return modlist[-1].sig_out[0] if len(modlist[-1].sig_out) == 1 else modlist[-1].sig_out

pymoto/modules/assembly.py

@@ -57,20 +57,21 @@ class AssembleGeneral(Module):
         self.bc = bc
         self.bcdiagval = np.max(element_matrix) if bcdiagval is None else bcdiagval
         if bc is not None:
-            self.bcselect = np.argwhere(np.bitwise_not(np.bitwise_or(np.isin(self.rows, self.bc),
-                                                                     np.isin(self.cols, self.bc)))).flatten()
-
-            self.rows = np.concatenate((self.rows[self.bcselect], self.bc))
-            self.cols = np.concatenate((self.cols[self.bcselect], self.bc))
+            bc_inds = np.bitwise_or(np.isin(self.rows, self.bc), np.isin(self.cols, self.bc))
+            self.bcselect = np.argwhere(np.bitwise_not(bc_inds)).flatten()
+            self.bcrows = np.concatenate((self.rows[self.bcselect], self.bc))
+            self.bccols = np.concatenate((self.cols[self.bcselect], self.bc))
         else:
             self.bcselect = None
+            self.bcrows = self.rows
+            self.bccols = self.cols
 
         self.add_constant = add_constant
 
     def _response(self, xscale: np.ndarray):
         nel = self.dofconn.shape[0]
         assert xscale.size == nel, f"Input vector wrong size ({xscale.size}), must be of size #nel ({nel})"
-        scaled_el = ((self.elmat.flatten()[np.newaxis]).T * xscale).flatten(order='F')
+        scaled_el = (self.elmat.flatten() * xscale[..., np.newaxis]).flatten()
 
         # Set boundary conditions
         if self.bc is not None:
@@ -80,7 +81,7 @@ class AssembleGeneral(Module):
             mat_values = scaled_el
 
         try:
-            mat = self.matrix_type((mat_values, (self.rows, self.cols)), shape=(self.n, self.n))
+            mat = self.matrix_type((mat_values, (self.bcrows, self.bccols)), shape=(self.n, self.n))
         except TypeError as e:
             raise type(e)(str(e) + "\n\tInvalid matrix_type={}. Either scipy.sparse.cscmatrix or "
                                    "scipy.sparse.csrmatrix are supported"
@@ -96,14 +97,16 @@ class AssembleGeneral(Module):
         if self.bc is not None:
             dgdmat[self.bc, :] = 0.0
             dgdmat[:, self.bc] = 0.0
+        dx = np.zeros_like(self.sig_in[0].state)
         if isinstance(dgdmat, np.ndarray):
-            dx = np.zeros_like(self.sig_in[0].state)
             for i in range(len(dx)):
                 indu, indv = np.meshgrid(self.dofconn[i], self.dofconn[i], indexing='ij')
-                dx[i] = einsum("ij,ij->", self.elmat, dgdmat[indu, indv])
-            return dx
+                dxi = einsum("ij,ij->", self.elmat, dgdmat[indu, indv])
+                dx[i] = np.real(dxi) if np.isrealobj(dx) else dxi
         elif isinstance(dgdmat, DyadCarrier):
-            return dgdmat.contract(self.elmat, self.dofconn, self.dofconn)
+            dxi = dgdmat.contract(self.elmat, self.dofconn, self.dofconn)
+            dx[:] = np.real(dxi) if np.isrealobj(dx) else dxi
+        return dx
 
 
 def get_B(dN_dx, voigt=True):
@@ -123,7 +126,7 @@ def get_B(dN_dx, voigt=True):
     """
     n_dim, n_shapefn = dN_dx.shape
     n_strains = int((n_dim * (n_dim+1))/2)  # Triangular number: ndim=3 -> nstrains = 3+2+1
-    B = np.zeros((n_strains, n_shapefn*n_dim))
+    B = np.zeros((n_strains, n_shapefn*n_dim), dtype=dN_dx.dtype)
     if n_dim == 1:
         for i in range(n_shapefn):
             B[i, 0] = dN_dx[i, 0]
@@ -222,7 +225,8 @@ class AssembleStiffness(AssembleGeneral):
         ndof = nnode*domain.dim
 
         # Element stiffness matrix
-        self.stiffness_element = np.zeros((ndof, ndof))
+        dtype = np.result_type(D, domain.element_size.dtype)
+        self.stiffness_element = np.zeros((ndof, ndof), dtype=dtype)
 
         # Numerical integration
         siz = domain.element_size

pymoto/modules/io.py

@@ -1,13 +1,9 @@
 import os
-import platform
 import numbers
-import sys
 from pathlib import Path
 import numpy as np
-if platform.system() == 'Darwin':  # Avoid "Python is not installed as a framework (Mac OS X)" error
-    # Change backend
-    import matplotlib
-    matplotlib.use('TkAgg')
+import matplotlib
+matplotlib.use('TkAgg')  # Change default backend -- TkAgg does not freeze during calculations
 import matplotlib.pyplot as plt
 
 from pymoto import Module
@@ -202,15 +198,16 @@ class PlotIter(FigModule):
         show (bool): Show the figure on the screen
         ylim: Provide y-axis limits for the plot
     """
-    def _prepare(self, ylim=None):
+    def _prepare(self, ylim=None, log_scale=False):
         self.minlim = 1e+200
         self.maxlim = -1e+200
         self.ylim = ylim
+        self.log_scale = log_scale
 
     def _response(self, *args):
         if not hasattr(self, 'ax'):
             self.ax = self.fig.add_subplot(111)
-            self.ax.set_yscale('linear')
+            self.ax.set_yscale('linear' if not self.log_scale else 'log')
             self.ax.set_xlabel("Iteration")
 
         if not hasattr(self, 'line'):
@@ -233,13 +230,24 @@ class PlotIter(FigModule):
             self.minlim = min(self.minlim, np.min(xadd))
             self.maxlim = max(self.maxlim, np.max(xadd))
 
-        dy = max((self.maxlim - self.minlim)*0.05, sys.float_info.min)
-
         self.ax.set_xlim([-0.5, self.iter+0.5])
         if self.ylim is not None:
             self.ax.set_ylim(self.ylim)
         elif np.isfinite(self.minlim) and np.isfinite(self.maxlim):
-            self.ax.set_ylim([self.minlim - dy, self.maxlim + dy])
+            if self.log_scale:
+                dy = (np.log10(self.maxlim) - np.log10(self.minlim))*0.05
+                ll = 10**(np.log10(self.minlim) - dy)
+                ul = 10**(np.log10(self.maxlim) + dy)
+            else:
+                dy = (self.maxlim - self.minlim)*0.05
+                ll = self.minlim - dy
+                ul = self.maxlim + dy
+
+            if ll == ul:
+                dy = abs(np.nextafter(abs(ll), 1) - abs(ll))
+                ll = ll - 1e5*dy
+                ul = ul + 1e5*dy
+            self.ax.set_ylim([ll, ul])
 
         self._update_fig()
 

pymoto/modules/linalg.py

@@ -268,7 +268,7 @@ class LinSolve(Module):
         if not isinstance(self.solver, LDAWrapper) and self.use_lda_solver:
             lda_kwargs = dict(hermitian=self.ishermitian, symmetric=self.issymmetric)
             if hasattr(self.solver, 'tol'):
-                lda_kwargs['tol'] = self.solver.tol * 2
+                lda_kwargs['tol'] = self.solver.tol * 5
             self.solver = LDAWrapper(self.solver, **lda_kwargs)
 
         # Update solver with new matrix
@@ -371,9 +371,11 @@ class EigenSolve(Module):
             Bqi = qi if B is None else B@qi
 
             normval = np.sqrt(qi @ Bqi)
-            avgval = np.average(qi)/normval
-
-            sf = np.sign(np.real(avgval)) / normval
+            sgn = 1 if np.real(np.average(qi)) >= 0 else -1
+            sf = sgn / normval
+            assert np.isfinite(sf)
+            if sf == 0.0:
+                warnings.warn(f"Scaling factor of mode {i} is zero!")
             qi *= sf
         return W, Q
 
@@ -423,8 +425,9 @@ class EigenSolve(Module):
         if self.is_hermitian:
             return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma, mode=self.mode)
         else:
-            # TODO
-            raise NotImplementedError('Non-Hermitian sparse matrix not supported')
+            if self.mode.lower() not in ['normal']:
+                raise NotImplementedError('Only `normal` mode can be selected for non-hermitian matrix')
+            return spsla.eigs(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma)
 
     def _dense_sens(self, A, B, dW, dQ):
         """ Calculates all (eigenvector and eigenvalue) sensitivities for dense matrix """
@@ -465,17 +468,14 @@ class EigenSolve(Module):
             qi = Q[:, i]
             qmq = qi@qi if B is None else qi @ (B @ qi)
             dA_u = (dwi/qmq) * qi
-            if np.isrealobj(A):
-                dA += DyadCarrier([np.real(dA_u), -np.imag(dA_u)], [np.real(qi), np.imag(qi)])
-            else:
-                dA += DyadCarrier(dA_u, qi)
+            dAi = DyadCarrier(dA_u, qi)
+            dA += np.real(dAi) if np.isrealobj(A) else dAi
 
             if dB is not None:
                 dB_u = (wi*dwi/qmq) * qi
-                if np.isrealobj(B):
-                    dB -= DyadCarrier([np.real(dB_u), -np.imag(dB_u)], [np.real(qi), np.imag(qi)])
-                else:
-                    dB -= DyadCarrier(dB_u, qi)
+                dBi = DyadCarrier(dB_u, qi)
+                dB -= np.real(dBi) if np.isrealobj(B) else dBi
+
         return dA, dB
 
     def _sparse_eigvec_sens(self, A, B, dW, dQ):

pymoto/routines.py

@@ -10,10 +10,10 @@ from scipy.sparse import issparse
 def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
     for s1 in sig1:
         while isinstance(s1, SignalSlice):
-            s1 = s1.orig_signal
+            s1 = s1.base
         for s2 in sig2:
             while isinstance(s2, SignalSlice):
-                s2 = s2.orig_signal
+                s2 = s2.base
             if s1 == s2:
                 return True
     return False

pymoto/solvers/iterative.py

@@ -132,7 +132,7 @@ class GeometricMultigrid(Preconditioner):
         assert cycle.lower() in self._available_cycles, f"Cycle ({cycle}) is not available. Options are {self._available_cycles}"
         self.cycle = cycle
         self.inner_level = None if inner_level is None else inner_level
-        self.smoother = DampedJacobi(w=0.5) if smoother is None else None
+        self.smoother = DampedJacobi(w=0.5) if smoother is None else smoother
         self.smooth_steps = smooth_steps
         self.R = None
         self.sub_domain = DomainDefinition(domain.nelx // 2, domain.nely // 2, domain.nelz // 2,
@@ -299,7 +299,7 @@ class CG(LinearSolver):
         self.A = A
         self.preconditioner.update(A)
         if self.verbosity >= 1:
-            print(f"Preconditioner set up in {np.round(time.perf_counter() - tstart,3)}s")
+            print(f"CG Preconditioner set up in {np.round(time.perf_counter() - tstart, 3)}s")
 
     def solve(self, rhs, x0=None, trans='N'):
         if trans == 'N':
@@ -321,10 +321,18 @@ class CG(LinearSolver):
             x = x.reshape((x.size, 1))
 
         r = b - A@x
+        tval = np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)
+        if self.verbosity >= 2:
+            print(f"CG Initial (max) residual = {tval.max()}")
+
+        if tval.max() <= self.tol:
+            if self.verbosity >= 1:
+                print(f"CG Converged in 0 iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
+
+            return x.flatten() if rhs.ndim == 1 else x
+
         z = self.preconditioner.solve(r, trans=trans)
         p = orth(z, normalize=True)
-        if self.verbosity >= 2:
-            print(f"Initial residual = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
 
         for i in range(self.maxit):
             q = A @ p
@@ -333,16 +341,15 @@ class CG(LinearSolver):
             alpha = pq_inv @ (p.conj().T @ r)
 
             x += p @ alpha
-            if i % 50 == 0:  # Explicit restart
+            if i % self.restart == 0:  # Explicit restart
                 r = b - A@x
             else:
                 r -= q @ alpha
 
+            tval = np.linalg.norm(r, axis=0)/np.linalg.norm(b, axis=0)
             if self.verbosity >= 2:
-                print(f"i = {i}, residuals = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
-
-            tval = np.linalg.norm(r)/np.linalg.norm(b)
-            if tval <= self.tol:
+                print(f"CG i = {i}, residuals = {tval}")
+            if tval.max() <= self.tol:
                 break
 
             z = self.preconditioner.solve(r, trans=trans)
@@ -350,12 +357,9 @@ class CG(LinearSolver):
             beta = -pq_inv @ (q.conj().T @ z)
             p = orth(z + p@beta, normalize=False)
 
-        if tval > self.tol:
-            warnings.warn(f'Maximum iterations ({self.maxit}) reached, with final residual {tval}')
+        if tval.max() > self.tol:
+            warnings.warn(f'CG Maximum iterations ({self.maxit}) reached, with final residuals {tval}')
         elif self.verbosity >= 1:
-            print(f"Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final residuals {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
+            print(f"CG Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
 
-        if rhs.ndim == 1:
-            return x.flatten()
-        else:
-            return x
+        return x.flatten() if rhs.ndim == 1 else x

pymoto/solvers/solvers.py

@@ -75,6 +75,17 @@ class LinearSolver:
         return np.linalg.norm(mat@x - b, axis=0) / np.linalg.norm(b, axis=0)
 
 
+def get_diagonal_indices(mat):
+    """ Get the row/column indices for entries in the matrix that are diagonal (has all zeros in its row and column) """
+    assert mat.ndim == 2, "Not a matrix"
+    n = min(*mat.shape)  # Matrix size
+    bmat = mat != 0
+    has_diag = bmat.diagonal()
+    nnz_rows = np.array(bmat.sum(axis=0)).flatten()[:n]
+    nnz_cols = np.array(bmat.sum(axis=1)).flatten()[:n]
+    return np.logical_and(has_diag, nnz_rows <= 1, nnz_cols <= 1)
+
+
 class LDAWrapper(LinearSolver):
     r""" Linear dependency aware solver (LDAS)
 
@@ -105,6 +116,8 @@ class LDAWrapper(LinearSolver):
         self.xadj_stored = []
         self.badj_stored = []
         self.A = None
+        self.diagonal_idx = []
+        self.nondiagonal_idx = slice(None)
         self._did_solve = False  # For debugging purposes
         self._last_rtol = 0.
         self.hermitian = hermitian
@@ -123,6 +136,9 @@ class LDAWrapper(LinearSolver):
             self.hermitian = matrix_is_hermitian(A)
 
         self.A = A
+        diags = get_diagonal_indices(A)
+        self.diagonal_idx = np.argwhere(diags).flatten()
+        self.nondiagonal_idx = np.argwhere(~diags).flatten()
         self.x_stored.clear()
         self.b_stored.clear()
         self.xadj_stored.clear()
@@ -130,6 +146,9 @@ class LDAWrapper(LinearSolver):
         self.solver.update(A)
 
     def _do_solve_1rhs(self, A, rhs, x_data, b_data, solve_fn, x0=None):
+        isel = self.nondiagonal_idx
+        idia = self.diagonal_idx
+
         dtype = np.result_type(A, rhs)
         if rhs.ndim == 1:
             rhs_loc = np.zeros((rhs.size, 1), dtype=dtype)
@@ -139,11 +158,16 @@ class LDAWrapper(LinearSolver):
             rhs_loc[:] = rhs
         sol = np.zeros_like(rhs_loc, dtype=dtype)
 
-        # Check linear dependencies in the rhs using modified Gram-Schmidt
+        # Diagonal part of the matrix
+        sol[idia, ...] = rhs_loc[idia, ...] / A.diagonal()[idia, None]
+        rhs_loc[idia, ...] = 0
+
+        # Non-diagonal part of the matrix
+        # Reconstruct using the database using modified Gram-Schmidt
         for (x, b) in zip(x_data, b_data):
             assert x.ndim == b.ndim == 1
-            assert x.size == b.size == rhs_loc.shape[0]
-            alpha = rhs_loc.T @ b.conj() / (b.conj() @ b)
+            # assert x.size == b.size == rhs_loc.shape[0]
+            alpha = rhs_loc[isel, ...].T @ b.conj() / (b.conj() @ b)
 
             rem_rhs = alpha * b[:, None]
             add_sol = alpha * x[:, None]
@@ -162,34 +186,41 @@ class LDAWrapper(LinearSolver):
                     warnings.warn('LDAS: Complex vector cannot be added to real solution')
                     continue
 
-            rhs_loc -= rem_rhs
-            sol += add_sol
+            rhs_loc[isel, ...] -= rem_rhs
+            sol[isel, ...] += add_sol
+
+        assert np.all(rhs_loc[idia, ...] == 0)
 
         # Check tolerance
-        self._last_rtol = np.ones(rhs_loc.shape[-1]) if len(x_data) == 0 else self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
+        self._last_rtol = self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
         self._did_solve = self._last_rtol > self.tol
+        # If tolerance too large, use the solver for new values
         if np.any(self._did_solve):
             if x0 is not None:
                 if x0.ndim == 1:
                     x0_loc = x0.reshape(-1, 1).copy()
                 else:
                     x0_loc = x0[..., self._did_solve].copy()
+                x0_loc[idia, ...] = 0
                 for x in x_data:
-                    beta = x0_loc.T @ x.conj() / (x.conj() @ x)
-                    x0_loc -= beta * x
+                    beta = x0_loc[isel, ...].T @ x.conj() / (x.conj() @ x)
+                    x0_loc[isel, ...] -= beta * x
             else:
                 x0_loc = None
 
-            # Calculate a new solution
+            # Calculate a new solution (for the vectors that have too high residual)
             xnew = solve_fn(rhs_loc[..., self._did_solve], x0_loc)
-            self.residual(A, xnew, rhs_loc[..., self._did_solve])
-            sol[..., self._did_solve] += xnew
+
+            if isinstance(isel, slice):
+                sol[isel, self._did_solve] += xnew[isel, ...]
+            else:
+                sol[np.ix_(isel, self._did_solve)] += xnew[isel, ...]
 
             # Add to database
             for i in range(xnew.shape[-1]):
                 # Remove all previous components that are already in the database (orthogonalize)
-                xadd = xnew[..., i]
-                badd = A @ xadd
+                xadd = xnew[isel, i]
+                badd = (A @ xnew[..., i])[isel, ...]
                 for x, b in zip(x_data, b_data):
                     beta = badd @ b.conj() / (b.conj() @ b)
                     badd -= beta * b

pymoto/solvers/sparse.py

@@ -140,6 +140,9 @@ class SolverSparsePardiso(LinearSolver):
         Returns:
             Solution of the system of linear equations, same shape as input b
         """
+        if b.dtype != np.float64:  # Only float64 is supported --> this is also done in _check_b, but fails for int8
+            warnings.warn(f"Array b's data type was converted from {b.dtype} to float64")
+            b = b.astype(np.float64)
         if trans == 'N':
             return self._pardiso_solver.solve(self.A, b)
         elif trans == 'T' or trans == 'H':
@@ -200,6 +203,13 @@ class SolverSparsePardiso(LinearSolver):
             if v != 0:
                 print(f"{i+1}: {v} ({k})")  # i+1 because of 1-based numbering
 
+    def __del__(self):
+        try:
+            self._pardiso_solver.free_memory(everything=True)
+        except ImportError:
+            # To prevent ImportError: sys.meta_path is None, Python is likely shutting down
+            pass
+
 
 # ------------------------------------ LU Solver -----------------------------------
 try:

{pyMOTO-1.5.0.dist-info → pymoto-1.5.1b1.dist-info}/METADATA

@@ -1,29 +1,37 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyMOTO
-Version: 1.5.0
-Summary: A modular approach for topology optimization
-Home-page: https://github.com/aatmdelissen/pyMOTO
-Author: Arnoud Delissen
-Author-email: arnouddelissen+pymoto@gmail.com
-License: MIT License
-Keywords: topology optimization,generative design,structural,sensitivities,derivatives,framework,modular,blocks,pipeline
+Version: 1.5.1b1
+Summary: A modular approach to topology optimization
+Author-email: Arnoud Delissen <arnouddelissen+pymoto@gmail.com>
+License: MIT
+Project-URL: Homepage, https://pymoto.readthedocs.io/
+Project-URL: Code, https://github.com/aatmdelissen/pyMOTO
+Project-URL: Documentation, https://pymoto.readthedocs.io/
+Project-URL: Issues, https://github.com/aatmdelissen/pyMOTO/issues
+Project-URL: Release notes, https://github.com/aatmdelissen/pyMOTO/releases/latest
+Keywords: topology optimization,generative design,sensitivity analysis,gradients,finite element method,structural optimization,mechanics,engineering
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: scipy >=1.7
+Requires-Dist: scipy>=1.7
 Requires-Dist: sympy
 Requires-Dist: matplotlib
 Provides-Extra: dev
-Requires-Dist: flake8 ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: cvxopt ; extra == 'dev'
-Requires-Dist: scikit-sparse ; extra == 'dev'
-Requires-Dist: pypardiso ; extra == 'dev'
-Requires-Dist: jax[cpu] ; extra == 'dev'
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: cvxopt; extra == "dev"
+Requires-Dist: scikit-sparse; extra == "dev"
+Requires-Dist: pypardiso; extra == "dev"
+Requires-Dist: opt-einsum; extra == "dev"
+Requires-Dist: jax[cpu]; extra == "dev"
+Dynamic: license-file
 
 [![10.5281/zenodo.8138859](https://zenodo.org/badge/DOI/10.5281/zenodo.8138859.svg)](https://doi.org/10.5281/zenodo.8138859) 
 [![anaconda.org/aatmdelissen/pymoto](https://anaconda.org/aatmdelissen/pymoto/badges/version.svg)](https://anaconda.org/aatmdelissen/pymoto)
@@ -51,7 +59,7 @@ automatically calculated.
 
 # Quick start installation
 1. Make sure you have Python running in some kind of virtual environment (e.g. 
-[conda](https://docs.conda.io/projects/conda/en/stable/), [miniconda](https://docs.conda.io/en/latest/miniconda.html),
+[uv](https://docs.astral.sh/uv/guides/install-python/), [conda](https://docs.conda.io/projects/conda/en/stable/), [miniconda](https://docs.conda.io/en/latest/miniconda.html),
 [venv](https://realpython.com/python-virtual-environments-a-primer/))
 2. Install the pymoto Python package (and its dependencies)
    - Option A (conda): If you are working with Conda, install by `conda install -c aatmdelissen pymoto`

pymoto-1.5.1b1.dist-info/RECORD

@@ -0,0 +1,28 @@
+pymoto/__init__.py,sha256=csgRTVQ2B0pIbQZYvpmL4RDcKYVoyc-vaio3UzlaQ-s,2064
+pymoto/core_objects.py,sha256=Amxn-338Igm2BT1O76wr6GgftQ3vgldj-aqHhJodGfA,28579
+pymoto/routines.py,sha256=inz5GbSnvmbD3WKmaNKATTc_SthKsAMPuRc8Jaub4xs,15568
+pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
+pymoto/common/domain.py,sha256=lstnJ-ITqtjLMQljoc5gN3XVgdFa7gXlMNWiG7IfcR4,18118
+pymoto/common/dyadcarrier.py,sha256=Q0MCIP4b-W_RuYxynvY-voCHfeZ4oF12ykAuVUnmLq4,19433
+pymoto/common/mma.py,sha256=SaFdZhpL5uoQRLWxQrElcjRMzGG4CL3BcPc77z3eMVE,24612
+pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
+pymoto/modules/assembly.py,sha256=o_HZ4bcyK6cMNWVsrmxvv2z6oDgQcrBmB6dquQCWGC8,23216
+pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
+pymoto/modules/complex.py,sha256=B_Obk-ABdV66lEudZ5s8o6qG9NsmYlBsX-PbWvbphhc,4429
+pymoto/modules/filter.py,sha256=6X9FaQMWYZ_TpHVTFiEibzlmAwmSWbydYM93LFrJ0Wo,25490
+pymoto/modules/generic.py,sha256=YzsGZ8J0oLCORt78Bf2p0v4GuqpWRI77NLoCk7gqidw,10666
+pymoto/modules/io.py,sha256=nWhXlDc3l-g-5GEY50yRLbbDAy7pay5Tm92pSgLfUIw,13553
+pymoto/modules/linalg.py,sha256=GIMqcIfVsMib5nIwrhx4sPT6-auLiHBJjbKCAdulLLE,22005
+pymoto/modules/scaling.py,sha256=uq88HHW9rP16XLz7UGc3CNBBpY2Z1glo8yjYxZEnXUg,2327
+pymoto/solvers/__init__.py,sha256=9JUeD2SgZbkYFullA7s7s6SuAVv0onqAqJ8hFvNOs2g,1033
+pymoto/solvers/auto_determine.py,sha256=X8MEG7h6jLfAV1inpja45_-suG8qQFMfLMDfW2ryQqQ,5134
+pymoto/solvers/dense.py,sha256=9fKPCwNxRKAEk5k1A7fdLrr9ngeVssGlw-sbjWCm4iU,11235
+pymoto/solvers/iterative.py,sha256=hfMRw2LChupr4sQf8qUKG6OHjhpeVAp6C9N7M4-845M,13179
+pymoto/solvers/matrix_checks.py,sha256=bbrfjpTSWWnuQW3xY0_CYE8yrh5gA9K5b1LzHEOFAxI,1663
+pymoto/solvers/solvers.py,sha256=Srn44oRonZIjJq-XVpJY9KoTWV0R7zBWFaSmXKWsUCw,11870
+pymoto/solvers/sparse.py,sha256=BPw-2Q4lgbmtjCl8eLEmDdWhjqD7RSLrVYy_kQN_LdU,17144
+pymoto-1.5.1b1.dist-info/licenses/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
+pymoto-1.5.1b1.dist-info/METADATA,sha256=Xt0HY8PX1nI1W1_xiWZNkin3vVXNenx-mvhMhn0F2wY,5510
+pymoto-1.5.1b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pymoto-1.5.1b1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
+pymoto-1.5.1b1.dist-info/RECORD,,

{pyMOTO-1.5.0.dist-info → pymoto-1.5.1b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyMOTO-1.5.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-pymoto/__init__.py,sha256=YLMAiO2PZHAC6nYWXVh03rhZnZkc_Rc2z7SGQj1T8I4,2058
-pymoto/core_objects.py,sha256=88AOo041wrcRSPoLCRwBXUoYANGX-b2SAA0Nuf6sn2Y,25252
-pymoto/routines.py,sha256=yjvcQDcWU47ZM6ZpZoX8VwrJoN9JDO_25DSa9oVcKec,15582
-pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=-eFuYRLehQ17Ai-cV59f4I9FbEM-DJAj6kjjVfj31X0,18120
-pymoto/common/dyadcarrier.py,sha256=VwMbqPr0NMDPfpsH0BwvXp8M1dmh8ijFDpF6yoyTmto,19394
-pymoto/common/mma.py,sha256=Pof3clOHA8PG51TmUjs11dkjSP96kovZjsPv62tI2Ec,24055
-pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
-pymoto/modules/assembly.py,sha256=quuR8QpB2w-O0zly-xS6PK6wZQMY6S5TWh15Y9wuh14,22974
-pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
-pymoto/modules/complex.py,sha256=B_Obk-ABdV66lEudZ5s8o6qG9NsmYlBsX-PbWvbphhc,4429
-pymoto/modules/filter.py,sha256=6X9FaQMWYZ_TpHVTFiEibzlmAwmSWbydYM93LFrJ0Wo,25490
-pymoto/modules/generic.py,sha256=YzsGZ8J0oLCORt78Bf2p0v4GuqpWRI77NLoCk7gqidw,10666
-pymoto/modules/io.py,sha256=LcFvJ-cPgg5ee-aag8kaxHw5RzQ-ggxOM5jk7PeJ1r8,13140
-pymoto/modules/linalg.py,sha256=BNkih4nvvkYuQpm4bG5U38dAjkfD5EFi3MjANpBEPPI,21927
-pymoto/modules/scaling.py,sha256=uq88HHW9rP16XLz7UGc3CNBBpY2Z1glo8yjYxZEnXUg,2327
-pymoto/solvers/__init__.py,sha256=9JUeD2SgZbkYFullA7s7s6SuAVv0onqAqJ8hFvNOs2g,1033
-pymoto/solvers/auto_determine.py,sha256=X8MEG7h6jLfAV1inpja45_-suG8qQFMfLMDfW2ryQqQ,5134
-pymoto/solvers/dense.py,sha256=9fKPCwNxRKAEk5k1A7fdLrr9ngeVssGlw-sbjWCm4iU,11235
-pymoto/solvers/iterative.py,sha256=CIxJHjGnCaIjXbtO2NxV60yeDpcCbSD6Bp0xR-7vOf0,12944
-pymoto/solvers/matrix_checks.py,sha256=bbrfjpTSWWnuQW3xY0_CYE8yrh5gA9K5b1LzHEOFAxI,1663
-pymoto/solvers/solvers.py,sha256=RwHjZYYlE3oA0U9k7ukla2gOdmq57rSSJQvHqjaM7JU,10626
-pymoto/solvers/sparse.py,sha256=w8XBlFBIfOpNnfRdLWhLzzqtD8YVxMnDBuhIabFfQQc,16664
-pyMOTO-1.5.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.5.0.dist-info/METADATA,sha256=hC38SdgeKEK5NkNDh-gwc4Gz2JOFSymJB-eAMXl7HX4,5006
-pyMOTO-1.5.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-pyMOTO-1.5.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.5.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.5.0.dist-info/RECORD,,

pyMOTO-1.5.0.dist-info/zip-safe

@@ -1 +0,0 @@
-