pyMOTO 1.3.0__tar.gz → 1.4.0__tar.gz

{pyMOTO-1.3.0 → pymoto-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.3.0
+Version: 1.4.0
 Summary: A modular approach for topology optimization
 Home-page: https://github.com/aatmdelissen/pyMOTO
 Author: Arnoud Delissen
@@ -25,7 +25,7 @@ Requires-Dist: scikit-sparse; extra == "dev"
 Requires-Dist: pypardiso; extra == "dev"
 Requires-Dist: jax[cpu]; extra == "dev"
 
-[![10.5281/zenodo.7708738](https://zenodo.org/badge/DOI/10.5281/zenodo.7708738.svg)](https://doi.org/10.5281/zenodo.7708738) 
+[![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)
 [![pypi.org/project/pyMOTO](https://badge.fury.io/py/pyMOTO.svg)](https://pypi.org/project/pyMOTO/)
 
@@ -61,15 +61,14 @@ automatically calculated.
 4. Run the example by typing `python ex_....py` in the console
 
 
-A local installation for development in `pyMOTO` can be done by first downloading the entire git repo, and then calling 
+For development, a local installation of `pyMOTO` can be done by first downloading/cloning the entire git repo, and then calling 
 `pip install -e .` in the `pyMOTO` folder (of course from within your virtual environment).
 
 ## Dependencies
-* **NumPy** - Dense linear algebra and solvers
-* **SciPy** - Sparse linear algebra and solvers
-* **SymPy** - Symbolic differentiation for `MathGeneral` module
-* **Matplotlib** - Plotting and visualisation
-* (optional) **SAO** - Sequential approximated optimizers
+* [**numpy**](https://numpy.org/doc/stable/) - Dense linear algebra and solvers
+* [**scipy**](https://docs.scipy.org/doc/scipy/) - Sparse linear algebra and solvers
+* [**sympy**](https://docs.sympy.org/latest/index.html) - Symbolic differentiation for `MathGeneral` module
+* [**Matplotlib**](https://matplotlib.org/stable/) - Plotting and visualisation
 * (optional) [**opt_einsum**](https://optimized-einsum.readthedocs.io/en/stable/install.html) - Optimized function for `EinSum` module
 
 For fast linear solvers for sparse matrices:

{pyMOTO-1.3.0 → pymoto-1.4.0}/README.md

@@ -1,4 +1,4 @@
-[![10.5281/zenodo.7708738](https://zenodo.org/badge/DOI/10.5281/zenodo.7708738.svg)](https://doi.org/10.5281/zenodo.7708738) 
+[![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)
 [![pypi.org/project/pyMOTO](https://badge.fury.io/py/pyMOTO.svg)](https://pypi.org/project/pyMOTO/)
 
@@ -34,15 +34,14 @@ automatically calculated.
 4. Run the example by typing `python ex_....py` in the console
 
 
-A local installation for development in `pyMOTO` can be done by first downloading the entire git repo, and then calling 
+For development, a local installation of `pyMOTO` can be done by first downloading/cloning the entire git repo, and then calling 
 `pip install -e .` in the `pyMOTO` folder (of course from within your virtual environment).
 
 ## Dependencies
-* **NumPy** - Dense linear algebra and solvers
-* **SciPy** - Sparse linear algebra and solvers
-* **SymPy** - Symbolic differentiation for `MathGeneral` module
-* **Matplotlib** - Plotting and visualisation
-* (optional) **SAO** - Sequential approximated optimizers
+* [**numpy**](https://numpy.org/doc/stable/) - Dense linear algebra and solvers
+* [**scipy**](https://docs.scipy.org/doc/scipy/) - Sparse linear algebra and solvers
+* [**sympy**](https://docs.sympy.org/latest/index.html) - Symbolic differentiation for `MathGeneral` module
+* [**Matplotlib**](https://matplotlib.org/stable/) - Plotting and visualisation
 * (optional) [**opt_einsum**](https://optimized-einsum.readthedocs.io/en/stable/install.html) - Optimized function for `EinSum` module
 
 For fast linear solvers for sparse matrices:

{pyMOTO-1.3.0 → pymoto-1.4.0}/pyMOTO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.3.0
+Version: 1.4.0
 Summary: A modular approach for topology optimization
 Home-page: https://github.com/aatmdelissen/pyMOTO
 Author: Arnoud Delissen
@@ -25,7 +25,7 @@ Requires-Dist: scikit-sparse; extra == "dev"
 Requires-Dist: pypardiso; extra == "dev"
 Requires-Dist: jax[cpu]; extra == "dev"
 
-[![10.5281/zenodo.7708738](https://zenodo.org/badge/DOI/10.5281/zenodo.7708738.svg)](https://doi.org/10.5281/zenodo.7708738) 
+[![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)
 [![pypi.org/project/pyMOTO](https://badge.fury.io/py/pyMOTO.svg)](https://pypi.org/project/pyMOTO/)
 
@@ -61,15 +61,14 @@ automatically calculated.
 4. Run the example by typing `python ex_....py` in the console
 
 
-A local installation for development in `pyMOTO` can be done by first downloading the entire git repo, and then calling 
+For development, a local installation of `pyMOTO` can be done by first downloading/cloning the entire git repo, and then calling 
 `pip install -e .` in the `pyMOTO` folder (of course from within your virtual environment).
 
 ## Dependencies
-* **NumPy** - Dense linear algebra and solvers
-* **SciPy** - Sparse linear algebra and solvers
-* **SymPy** - Symbolic differentiation for `MathGeneral` module
-* **Matplotlib** - Plotting and visualisation
-* (optional) **SAO** - Sequential approximated optimizers
+* [**numpy**](https://numpy.org/doc/stable/) - Dense linear algebra and solvers
+* [**scipy**](https://docs.scipy.org/doc/scipy/) - Sparse linear algebra and solvers
+* [**sympy**](https://docs.sympy.org/latest/index.html) - Symbolic differentiation for `MathGeneral` module
+* [**Matplotlib**](https://matplotlib.org/stable/) - Plotting and visualisation
 * (optional) [**opt_einsum**](https://optimized-einsum.readthedocs.io/en/stable/install.html) - Optimized function for `EinSum` module
 
 For fast linear solvers for sparse matrices:

{pyMOTO-1.3.0 → pymoto-1.4.0}/pyMOTO.egg-info/SOURCES.txt

@@ -15,9 +15,7 @@ pymoto/utils.py
 pymoto/common/domain.py
 pymoto/common/dyadcarrier.py
 pymoto/common/mma.py
-pymoto/common/solvers.py
-pymoto/common/solvers_dense.py
-pymoto/common/solvers_sparse.py
+pymoto/modules/aggregation.py
 pymoto/modules/assembly.py
 pymoto/modules/autodiff.py
 pymoto/modules/complex.py
@@ -26,13 +24,23 @@ pymoto/modules/generic.py
 pymoto/modules/io.py
 pymoto/modules/linalg.py
 pymoto/modules/scaling.py
+pymoto/solvers/__init__.py
+pymoto/solvers/auto_determine.py
+pymoto/solvers/dense.py
+pymoto/solvers/iterative.py
+pymoto/solvers/matrix_checks.py
+pymoto/solvers/solvers.py
+pymoto/solvers/sparse.py
+tests/test_aggregration.py
 tests/test_assembly.py
 tests/test_automod.py
 tests/test_complex.py
 tests/test_core.py
 tests/test_domain.py
 tests/test_dyadcarrier.py
+tests/test_element_operations.py
 tests/test_elmatrices.py
+tests/test_filter.py
 tests/test_linsolve_sparse.py
 tests/test_module_concatsignal.py
 tests/test_module_eigensolve.py
@@ -40,5 +48,6 @@ tests/test_module_einsum.py
 tests/test_module_mathgeneral.py
 tests/test_scaling.py
 tests/test_solvers_dense.py
+tests/test_solvers_iterative.py
 tests/test_solvers_sparse.py
 tests/test_static_condenstation.py

{pyMOTO-1.3.0 → pymoto-1.4.0}/pymoto/__init__.py

@@ -1,25 +1,27 @@
-__version__ = '1.3.0'
+__version__ = '1.4.0'
 
 from .common.domain import DomainDefinition
 
 # Imports from common
 from .common.dyadcarrier import DyadCarrier
 from .common.mma import MMA
-from .common.solvers import matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian, LinearSolver, LDAWrapper
-from .common.solvers_dense import SolverDiagonal, SolverDenseQR, SolverDenseLU, SolverDenseCholesky, SolverDenseLDL
-from .common.solvers_sparse import SolverSparsePardiso, SolverSparseLU, SolverSparseCholeskyScikit, SolverSparseCholeskyCVXOPT
+
+# Import solvers
+from . import solvers
 
 # Modular inports
 from .core_objects import Signal, Module, Network, make_signals
 
 # Import modules
 from .modules.assembly import AssembleGeneral, AssembleStiffness, AssembleMass, AssemblePoisson
+from .modules.assembly import ElementOperation, Strain, Stress
 from .modules.autodiff import AutoMod
 from .modules.complex import MakeComplex, RealPart, ImagPart, ComplexNorm
 from .modules.filter import FilterConv, Filter, DensityFilter, OverhangFilter
 from .modules.generic import MathGeneral, EinSum, ConcatSignal
-from .modules.io import PlotDomain, PlotGraph, PlotIter, WriteToVTI
+from .modules.io import FigModule, PlotDomain, PlotGraph, PlotIter, WriteToVTI
 from .modules.linalg import Inverse, LinSolve, EigenSolve, SystemOfEquations, StaticCondensation
+from .modules.aggregation import AggScaling, AggActiveSet, Aggregation, PNorm, SoftMinMax, KSFunction
 from .modules.scaling import Scaling
 
 # Further helper routines
@@ -28,21 +30,25 @@ from .routines import finite_difference, minimize_oc, minimize_mma
 __all__ = [
     'Signal', 'Module', 'Network', 'make_signals',
     'finite_difference', 'minimize_oc', 'minimize_mma',
+
     # Common
     'MMA',
     'DyadCarrier',
     'DomainDefinition',
-    'matrix_is_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
-    'LinearSolver', 'LDAWrapper',
-    'SolverDiagonal', 'SolverDenseQR', 'SolverDenseLU', 'SolverDenseCholesky', 'SolverDenseLDL',
-    'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',
+    'solvers',
+
+    # Helpers
+    "AggScaling", "AggActiveSet",
+
     # Modules
     "MathGeneral", "EinSum", "ConcatSignal",
     "Inverse", "LinSolve", "EigenSolve", "SystemOfEquations", "StaticCondensation",
     "AssembleGeneral", "AssembleStiffness", "AssembleMass", "AssemblePoisson",
+    "ElementOperation", "Strain", "Stress",
     "FilterConv", "Filter", "DensityFilter", "OverhangFilter",
-    "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI",
+    "FigModule", "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI",
     "MakeComplex", "RealPart", "ImagPart", "ComplexNorm",
     "AutoMod",
-    "Scaling"
+    "Aggregation", "PNorm", "SoftMinMax", "KSFunction",
+    "Scaling",
 ]

{pyMOTO-1.3.0 → pymoto-1.4.0}/pymoto/common/domain.py

@@ -5,6 +5,31 @@ import struct
 import warnings
 from typing import Union
 import numpy as np
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path
+
+
+def plot_deformed_element(ax, x, y, **kwargs):
+    codes, verts = zip(*[
+        (Path.MOVETO, [x[0], y[0]]),
+        (Path.LINETO, [x[1], y[1]]),
+        (Path.LINETO, [x[3], y[3]]),
+        (Path.LINETO, [x[2], y[2]]),
+        (Path.CLOSEPOLY, [x[0], y[0]])])
+    path = Path(verts, codes)
+    patch = PathPatch(path, **kwargs)
+    ax.add_artist(patch)
+    return patch
+
+
+def get_path(x, y):
+    codes, verts = zip(*[
+        (Path.MOVETO, [x[0], y[0]]),
+        (Path.LINETO, [x[1], y[1]]),
+        (Path.LINETO, [x[3], y[3]]),
+        (Path.LINETO, [x[2], y[2]]),
+        (Path.CLOSEPOLY, [x[0], y[0]])])
+    return Path(verts, codes)
 
 
 class DomainDefinition:
@@ -100,6 +125,13 @@ class DomainDefinition:
         self.conn = np.zeros((self.nel, self.elemnodes), dtype=int)
         self.conn[el, :] = self.get_elemconnectivity(elx, ely, elz)
 
+        # Helper for element slicing
+        eli, elj, elk = np.meshgrid(np.arange(self.nelx), np.arange(self.nely), np.arange(self.nelz), indexing='ij')
+        self.elements = self.get_elemnumber(eli, elj, elk)
+
+        ndi, ndj, ndk = np.meshgrid(np.arange(self.nelx+1), np.arange(self.nely+1), np.arange(self.nelz+1), indexing='ij')
+        self.nodes = self.get_nodenumber(ndi, ndj, ndk)
+
     def get_elemnumber(self, eli: Union[int, np.ndarray], elj: Union[int, np.ndarray], elk: Union[int, np.ndarray] = 0):
         """ Gets the element number(s) for element(s) with given Cartesian indices (i, j, k)
 
@@ -126,7 +158,7 @@ class DomainDefinition:
         """
         return (nodk * (self.nely + 1) + nodj) * (self.nelx + 1) + nodi
 
-    def get_node_indices(self, nod_idx: Union[int, np.ndarray]):
+    def get_node_indices(self, nod_idx: Union[int, np.ndarray] = None):
         """ Gets the Cartesian index (i, j, k) for given node number(s)
 
         Args:
@@ -135,16 +167,18 @@ class DomainDefinition:
         Returns:
             i, j, k for requested node(s); k is only returned in 3D
         """
+        if nod_idx is None:
+            nod_idx = np.arange(self.nnodes)
         nodi = nod_idx % (self.nelx + 1)
         nodj = (nod_idx // (self.nelx + 1)) % (self.nely + 1)
         if self.dim == 2:
-            return nodi, nodj
+            return np.stack([nodi, nodj], axis=0)
         nodk = nod_idx // ((self.nelx + 1)*(self.nely + 1))
-        return nodi, nodj, nodk
+        return np.stack([nodi, nodj, nodk], axis=0)
 
-    def get_node_position(self, nod_idx: Union[int, np.ndarray]):
+    def get_node_position(self, nod_idx: Union[int, np.ndarray] = None):
         ijk = self.get_node_indices(nod_idx)
-        return [idx * self.element_size[ii] for ii, idx in enumerate(ijk)]
+        return (self.element_size[:self.dim] * ijk.T).T
 
     def get_elemconnectivity(self, i: Union[int, np.ndarray], j: Union[int, np.ndarray], k: Union[int, np.ndarray] = 0):
         """ Get the connectivity for element identified with Cartesian indices (i, j, k)
@@ -230,6 +264,27 @@ class DomainDefinition:
             dN_dx[i, :] *= np.array([n[i] for n in self.node_numbering])  # Flip +/- signs according to node position
         return dN_dx
 
+    def plot(self, ax, deformation=None, scaling=None):
+        patches = []
+        for e in range(self.nel):
+            n = self.conn[e]
+            x, y = self.get_node_position(n)
+            u, v = deformation[n * 2], deformation[n * 2 + 1]
+            color = (1 - scaling[e], 1 - scaling[e], 1 - scaling[e]) if scaling is not None else 'grey'
+            patch = plot_deformed_element(ax, x + u, v + y, linewidth=0.1, color=color)
+            patches.append(patch)
+        return patches
+
+    def update_plot(self, patches, deformation=None, scaling=None):
+        for e in range(self.nel):
+            patch = patches[e]
+            n = self.conn[e]
+            x, y = self.get_node_position(n)
+            u, v = deformation[n * 2], deformation[n * 2 + 1]
+            color = (1 - scaling[e], 1 - scaling[e], 1 - scaling[e]) if scaling is not None else 'grey'
+            patch.set_color(color)
+            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)):
         """ Write all given vectors to a Paraview (VTI) file

{pyMOTO-1.3.0 → pymoto-1.4.0}/pymoto/common/dyadcarrier.py

@@ -1,8 +1,8 @@
-from typing import Union, Iterable
+from typing import Union, Iterable, List
 import warnings
 import numpy as np
 from numpy.typing import NDArray
-from scipy.sparse import spmatrix
+from scipy.sparse import spmatrix, coo_matrix
 from ..utils import _parse_to_list
 try:  # Import fast optimized einsum
     from opt_einsum import contract as einsum
@@ -31,7 +31,7 @@ def isnullslice(x):
 
 
 class DyadCarrier(object):
-    """ Efficient storage for dyadic or rank-N matrix
+    r""" Efficient storage for dyadic or rank-N matrix
 
     Stores only the vectors instead of creating a full rank-N matrix
     :math:`\mathbf{A} = \sum_k^N \mathbf{u}_k\otimes\mathbf{v}_k`
@@ -67,7 +67,7 @@ class DyadCarrier(object):
             return self.ulen * self.vlen
 
     def add_dyad(self, u: Iterable, v: Iterable = None, fac: float = None):
-        """ Adds a list of vectors to the dyad carrier
+        r""" Adds a list of vectors to the dyad carrier
 
         Checks for conforming sizes of `u` and `v`. The data inside the vectors are copied.
 
@@ -373,6 +373,31 @@ class DyadCarrier(object):
 
         return val
 
+    def contract_multi(self, mats: List[spmatrix], dtype=None):
+        """ Faster version of contraction for a list of sparse matrices """
+        if dtype is None:
+            dtype = np.result_type(self.dtype, mats[0].dtype)
+        val = np.zeros(len(mats), dtype=dtype)
+
+        if len(self.u) == 0 or len(self.v) == 0:
+            return val
+        U = np.array(self.u).T
+        V = np.array(self.v).T
+
+        for i, m in enumerate(mats):
+            if m is None:
+                vali = 0.0
+            else:
+                try:
+                    if not isinstance(m, coo_matrix):
+                        warnings.warn("Inefficiency: Matrix must be converted to coo_matrix for contraction")
+                    mat_coo = m.tocoo()
+                    vali = np.einsum('ij,i,ij->', U[mat_coo.row, :], mat_coo.data, V[mat_coo.col, :])
+                except AttributeError:
+                    vali = self.contract(m)
+            val[i] = vali
+        return val
+
     def todense(self):
         """ Returns a full (dense) matrix from the DyadCarrier matrix """
         warning_size = 100e+6  # Bytes
@@ -387,6 +412,10 @@ class DyadCarrier(object):
 
         return val
 
+    def toarray(self):
+        """ Convert to array, same as todense(). To be consistent with scipy.sparse """
+        return self.todense()
+
     def iscomplex(self):
         """ Check if the DyadCarrier is of complex type """
         return np.iscomplexobj(np.array([], dtype=self.dtype))

{pyMOTO-1.3.0 → pymoto-1.4.0}/pymoto/common/mma.py

@@ -219,11 +219,16 @@ class MMA:
         xmin: Minimum design variable (can be a vector)
         xmax: Maximum design variable (can be a vector)
         fn_callback: A function that is called just before calling the response() in each iteration
-        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info, 3 - Extended info
+        verbosity: Level of information to print
+          0 - No prints
+          1 - Only convergence message
+          2 - Convergence and iteration info (default)
+          3 - Additional info on variables
+          4 - Additional info on sensitivity information
 
     """
 
-    def __init__(self, function, variables, responses, tolx=1e-4, tolf=0.0, move=0.1, maxit=100, xmin=0.0, xmax=1.0, fn_callback=None, verbosity=0, **kwargs):
+    def __init__(self, function, variables, responses, tolx=1e-4, tolf=0.0, move=0.1, maxit=100, xmin=0.0, xmax=1.0, fn_callback=None, verbosity=2, **kwargs):
         self.funbl = function
         self.verbosity = verbosity
 
@@ -301,8 +306,7 @@ class MMA:
                 self.xmin[self.cumlens[i]:self.cumlens[i+1]] = xminvals[i]
 
         if len(self.xmin) != self.n:
-            raise RuntimeError(
-                "Length of the xmin vector not correct ({} != {})".format(len(self.xmin), self.n))
+            raise RuntimeError(f"Length of the xmin vector ({len(self.xmin)}) should be equal to # design variables ({self.n})")
 
         if not hasattr(self.xmax, '__len__'):
             self.xmax = self.xmax * np.ones_like(xval)
@@ -313,17 +317,19 @@ class MMA:
                 self.xmax[self.cumlens[i]:self.cumlens[i + 1]] = xmaxvals[i]
 
         if len(self.xmax) != self.n:
-            raise RuntimeError("Length of the xmax vector not correct ({} != {})".format(len(self.xmax), self.n))
+            raise RuntimeError(f"Length of the xmax vector ({len(self.xmax)}) should be equal to # design variables ({self.n})")
 
-        # Set movelimit in case of multiple
         if hasattr(self.move, '__len__'):
-            if len(self.move) == len(self.variables):
-                movevals = self.move
+            # Set movelimit in case of multiple are given
+            move_input = np.asarray(self.move).copy()
+            if move_input.size == len(self.variables):
                 self.move = np.zeros_like(xval)
-                for i in range(len(movevals)):
-                    self.move[self.cumlens[i]:self.cumlens[i + 1]] = movevals[i]
+                for i in range(move_input.size):
+                    self.move[self.cumlens[i]:self.cumlens[i + 1]] = move_input[i]
             elif len(self.move) != self.n:
-                raise RuntimeError("Length of the move vector not correct ({} != {})".format(len(self.move), self.n))
+                raise RuntimeError(f"Length of the move vector ({len(self.move)}) should be equal to number of "
+                                   f"design variable signals ({len(self.variables)}) or "
+                                   f"total number of design variables ({self.n}).")
 
         fcur = 0.0
         while self.iter < self.maxIt:
@@ -333,12 +339,9 @@ class MMA:
             # Set the new states
             for i, s in enumerate(self.variables):
                 if self.cumlens[i+1]-self.cumlens[i] == 1:
-                    try:
-                        s.state[:] = xval[self.cumlens[i]]
-                    except TypeError:
-                        s.state = xval[self.cumlens[i]]
+                    s.state = xval[self.cumlens[i]]
                 else:
-                    s.state[:] = xval[self.cumlens[i]:self.cumlens[i+1]]
+                    s.state = xval[self.cumlens[i]:self.cumlens[i+1]]
 
             if self.fn_callback is not None:
                 self.fn_callback()
@@ -346,19 +349,11 @@ class MMA:
             # Calculate response
             self.funbl.response()
 
-            # Update the states
-            for i, s in enumerate(self.variables):
-                if self.cumlens[i+1]-self.cumlens[i] == 1:
-                    try:
-                        xval[self.cumlens[i]] = s.state[:]
-                    except (TypeError, IndexError):
-                        xval[self.cumlens[i]] = s.state
-                else:
-                    xval[self.cumlens[i]:self.cumlens[i+1]] = s.state[:]
-
             # Save response
             f = ()
             for s in self.responses:
+                if not np.isscalar(s.state):
+                    raise TypeError("State of responses must be scalar.")
                 f += (s.state, )
 
             # Check function change convergence criterion
@@ -388,27 +383,48 @@ class MMA:
                 # Reset sensitivities for the next response
                 self.funbl.reset()
 
-            # Display info on variables
             if self.verbosity >= 3:
+                # Display info on variables
+                show_sensitivities = self.verbosity >= 4
+                msg = ""
                 for i, s in enumerate(self.variables):
-                    isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
-                    msg = "{0:>10s} = ".format(s.tag)
-                    if isscal:
-                        try:
-                            msg += "         {0: .3e}         ".format(s.state)
-                        except TypeError:
-                            msg += "         {0: .3e}         ".format(s.state[0])
+                    if show_sensitivities:
+                        msg += "{0:>10s} = ".format(s.tag[:10])
                     else:
-                        msg += "[{0: .3e} ... {1: .3e}] ".format(min(s.state), max(s.state))
-                    for j, s_out in enumerate(self.responses):
-                        msg += "| {0:>10s}/{1:10s} = ".format("d"+s_out.tag, "d"+s.tag)
-                        if isscal:
-                            msg += "         {0: .3e}         ".format(df[j][self.cumlens[i]])
+                        msg += f"{s.tag} = "
+
+                    # Display value range
+                    fmt = '% .2e'
+                    minval, maxval = np.min(s.state), np.max(s.state)
+                    mintag, maxtag = fmt % minval, fmt % maxval
+                    if mintag == maxtag:
+                        if show_sensitivities:
+                            msg += f"       {mintag}      "
                         else:
-                            msg += "[{0: .3e} ... {1: .3e}] ".format(min(df[j][self.cumlens[i]:self.cumlens[i+1]]), max(df[j][self.cumlens[i]:self.cumlens[i+1]]))
-                    print(msg)
+                            msg += f" {mintag}"
+                    else:
+                        sep = '…' if len(s.state) > 2 else ','
+                        msg += f"[{mintag}{sep}{maxtag}]"
+                        if show_sensitivities:
+                            msg += " "
+
+                    if show_sensitivities:
+                        # Display info on sensivity values
+                        for j, s_out in enumerate(self.responses):
+                            msg += "| {0:s}/{1:11s} = ".format("d" + s_out.tag, "d" + s.tag[:10])
+                            minval = np.min(df[j][self.cumlens[i]:self.cumlens[i+1]])
+                            maxval = np.max(df[j][self.cumlens[i]:self.cumlens[i+1]])
+                            mintag, maxtag = fmt % minval, fmt % maxval
+                            if mintag == maxtag:
+                                msg += f"       {mintag}      "
+                            else:
+                                sep = '…' if self.cumlens[i + 1] - self.cumlens[i] > 2 else ','
+                                msg += f"[{mintag}{sep}{maxtag}] "
+                        msg += '\n'
+                    elif i != len(self.variables)-1:
+                        msg += ', '
+                print(msg)
 
-            self.iter += 1
             xnew, change = self.mmasub(xval.copy(), np.hstack(f), np.vstack(df))
 
             # Stopping criteria on step size
@@ -419,6 +435,7 @@ class MMA:
                 break
 
             xval = xnew
+            self.iter += 1
 
     def mmasub(self, xval, g, dg):
         if self.dx is None:
@@ -535,20 +552,33 @@ class MMA:
         change = np.average(abs(xval - xmma))
 
         if self.verbosity >= 2:
+            # Display iteration status message
             msgs = ["g{0:d}({1:s}): {2:+.4e}".format(i, s.tag, g[i]) for i, s in enumerate(self.responses)]
-            print("It. {0: 4d}, {1}".format(self.iter, ", ".join(msgs)))
+            max_infeasibility = max(g[1:])
+            is_feasible = max_infeasibility <= 0
+
+            feasibility_tag = 'f' if is_feasible else ' '
+            print("It. {0: 4d}, [{1:1s}] {2}".format(self.iter, feasibility_tag, ", ".join(msgs)))
 
-        if self.verbosity >=3:
-            # Print changes
-            printstr = "Changes: "
+        if self.verbosity >= 3:
+            # Report design feasibility
+            iconst_max = np.argmax(g[1:])
+            print(f"  | {np.sum(g[1:]>0)} / {len(g)-1} violated constraints, "
+                  f"max. violation ({self.responses[iconst_max+1].tag}) = {'%.2g'%g[iconst_max+1]}")
+
+            # Print design changes
+            change_msgs = []
             for i, s in enumerate(self.variables):
-                isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
-                if isscal:
-                    chg = abs(xval[self.cumlens[i]] - xmma[self.cumlens[i]])
+                minchg = np.min(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                maxchg = np.max(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                fmt = '%.2g'
+                mintag, maxtag = fmt % minchg, fmt % maxchg
+
+                if mintag == maxtag:
+                    change_msgs.append(f"Δ({s.tag}) = {mintag}")
                 else:
-                    chg = np.average(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+                    change_msgs.append(f"Δ({s.tag}) = {mintag}…{maxtag}")
 
-                printstr += "{0:s} = {1:.3e}   ".format("Δ_"+s.tag, chg)
-            print(printstr)
+            print(f"  | Changes: {', '.join(change_msgs)}")
 
-        return xmma, change
+        return xmma, change