pyMOTO 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

{pyMOTO-1.3.0.dist-info → pyMOTO-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.3.0
+Version: 1.5.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.5.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+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.3.0.dist-info → pyMOTO-1.5.0.dist-info}/WHEEL

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

pymoto/__init__.py

@@ -1,25 +1,27 @@
-__version__ = '1.3.0'
+__version__ = '1.5.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, ElementAverage, NodalOperation, ThermoMechanical
 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, ScalarToFile
 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", "ElementAverage", "NodalOperation", "ThermoMechanical",
     "FilterConv", "Filter", "DensityFilter", "OverhangFilter",
-    "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI",
+    "FigModule", "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI", "ScalarToFile",
     "MakeComplex", "RealPart", "ImagPart", "ComplexNorm",
     "AutoMod",
-    "Scaling"
+    "Aggregation", "PNorm", "SoftMinMax", "KSFunction",
+    "Scaling",
 ]

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,14 @@ 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(max(self.nelz, 1)), indexing='ij')
+        self.elements = self.get_elemnumber(eli, elj, elk)
+
+        # Helper for node slicing
+        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 +159,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 +168,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 +265,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/common/dyadcarrier.py

@@ -1,8 +1,8 @@
-from typing import Union, Iterable
+from typing import Union, Iterable, List, Tuple
 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,25 +31,26 @@ 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`
     or in index notation :math:`A_{ij} = \sum_k^N u_{ki} v_{kj}`. This saves a lot of memory for low :math:`N`.
 
-    Args:
-        u : (optional) List of vectors
-        v : (optional) List of vectors (if ``u`` is given and ``v`` not, a symmetric dyad is assumed with ``v = u``)
+    Keyword Args:
+        u: List of vectors
+        v: List of vectors (if ``u`` is given and ``v`` not, a symmetric dyad is assumed with ``v = u``)
+        shape: Shape of the matrix
     """
 
     __array_priority__ = 11.0  # For overriding numpy's ufuncs
     ndim = 2  # Number of dimensions
 
-    def __init__(self, u: Iterable = None, v: Iterable = None):
+    def __init__(self, u: Iterable = None, v: Iterable = None, shape: Tuple[int, int] = (-1, -1)):
         self.u = []
         self.v = []
-        self.ulen = -1
-        self.vlen = -1
+        self.ulen = shape[0]
+        self.vlen = shape[1]
         self.dtype = np.dtype('float64')  # Standard data type
         self.add_dyad(u, v)
 
@@ -66,8 +67,14 @@ class DyadCarrier(object):
         else:
             return self.ulen * self.vlen
 
+    @property
+    def n_dyads(self):
+        """ Number of dyads stored """
+        assert len(self.u) == len(self.v)
+        return len(self.u)
+
     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.
 
@@ -92,9 +99,7 @@ class DyadCarrier(object):
         if len(ulist) != len(vlist):
             raise TypeError("Number of vectors in u ({}) and v({}) should be equal".format(len(ulist), len(vlist)))
 
-        n = len(ulist)
-
-        for i, ui, vi in zip(range(n), ulist, vlist):
+        for i, (ui, vi) in enumerate(zip(ulist, vlist)):
             # Make sure they are numpy arrays
             if not isinstance(ui, np.ndarray):
                 ui = np.array(ui)
@@ -141,14 +146,22 @@ class DyadCarrier(object):
 
     def __getitem__(self, subscript):
         assert len(subscript) == self.ndim, "Invalid number of slices, must be 2"
-        usub = [ui[subscript[0]] for ui in self.u]
-        vsub = [vi[subscript[1]] for vi in self.v]
+        if self.shape[0] < 0 and self.shape[1] < 0:
+            return DyadCarrier()
+
+        usample = np.zeros(self.shape[0])[subscript[0]]
+        vsample = np.zeros(self.shape[1])[subscript[1]]
 
-        is_uni_slice = isscalarlike(usub[0]) or isscalarlike(vsub[0])
+        is_uni_slice = isscalarlike(usample) or isscalarlike(vsample)
         is_np_slice = isinstance(subscript[0], np.ndarray) and isinstance(subscript[1], np.ndarray)
+
         if is_np_slice and subscript[0].shape != subscript[1].shape:
             raise IndexError(f"shape mismatch: indexing arrays could not be broadcast together "
                              f"with shapes {subscript[0].shape} {subscript[1].shape}")
+
+        usub = [ui[subscript[0]] for ui in self.u]
+        vsub = [vi[subscript[1]] for vi in self.v]
+
         if is_uni_slice or is_np_slice:
             res = 0
             for (ui, vi) in zip(usub, vsub):
@@ -156,7 +169,7 @@ class DyadCarrier(object):
 
             return res
         else:
-            return DyadCarrier(usub, vsub)
+            return DyadCarrier(usub, vsub, shape=(np.size(usample), np.size(vsample)))
 
     def __setitem__(self, subscript, value):
         assert len(subscript) == self.ndim, "Invalid number of slices, must be 2"
@@ -171,10 +184,10 @@ class DyadCarrier(object):
                 vi[subscript[1]] = value
 
     def __pos__(self):
-        return DyadCarrier(self.u, self.v)
+        return self.copy()
 
     def __neg__(self):
-        return DyadCarrier([-uu for uu in self.u], self.v)
+        return DyadCarrier([-uu for uu in self.u], self.v, shape=self.shape)
 
     def __iadd__(self, other):
         self.add_dyad(other.u, other.v)
@@ -189,7 +202,7 @@ class DyadCarrier(object):
         elif isdyad(other):
             if other.shape != self.shape and (self.size > 0 and other.size > 0):
                 raise ValueError(f"Inconsistent shapes {self.shape} and {other.shape}")
-            return DyadCarrier(self.u, self.v).__iadd__(other)
+            return self.copy().__iadd__(other)
         elif isdense(other):
             other = np.broadcast_to(other, self.shape)
             return other + self.todense()
@@ -219,28 +232,44 @@ class DyadCarrier(object):
             return NotImplemented
 
     def __rmul__(self, other):  # other * self
-        return DyadCarrier([other*ui for ui in self.u], self.v)
+        return DyadCarrier([other*ui for ui in self.u], self.v, shape=self.shape)
 
     def __mul__(self, other):  # self * other
-        return DyadCarrier(self.u, [vi*other for vi in self.v])
+        return DyadCarrier(self.u, [vi*other for vi in self.v], shape=self.shape)
 
     def copy(self):
         """ Returns a deep copy of the DyadCarrier """
-        return DyadCarrier(self.u, self.v)
+        return DyadCarrier(self.u, self.v, shape=self.shape)
 
     def conj(self):
         """ Returns (a deep copied) complex conjugate of the DyadCarrier """
-        return DyadCarrier([u.conj() for u in self.u], [v.conj() for v in self.v])
+        return DyadCarrier([u.conj() for u in self.u], [v.conj() for v in self.v], shape=self.shape)
 
     @property
     def real(self):
         """ Returns a deep copy of the real part of the DyadCarrier """
-        return DyadCarrier([*[u.real for u in self.u], *[-u.imag for u in self.u]], [*[v.real for v in self.v], *[v.imag for v in self.v]])
+        return DyadCarrier([*[u.real for u in self.u], *[-u.imag for u in self.u]], [*[v.real for v in self.v], *[v.imag for v in self.v]], shape=self.shape)
 
     @property
     def imag(self):
         """ Returns a deep copy of the imaginary part of the DyadCarrier """
-        return DyadCarrier([*[u.real for u in self.u], *[u.imag for u in self.u]], [*[v.imag for v in self.v], *[v.real for v in self.v]])
+        return DyadCarrier([*[u.real for u in self.u], *[u.imag for u in self.u]], [*[v.imag for v in self.v], *[v.real for v in self.v]], shape=self.shape)
+
+    def min(self):
+        minval = 0.0
+        for u, v in zip(self.u, self.v):
+            minval += u.min() * v.min()
+        if len(self.u) >= 2:
+            warnings.warn("The minimum is an approximation")
+        return minval
+
+    def max(self):
+        maxval = 0.0
+        for u, v in zip(self.u, self.v):
+            maxval += u.max() * v.max()
+        if len(self.u) >= 2:
+            warnings.warn("The maximum is an approximation")
+        return maxval
 
     # flake8: noqa: C901
     def contract(self, mat: Union[NDArray, spmatrix] = None, rows: NDArray[int] = None, cols: NDArray[int] = None):
@@ -373,6 +402,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 +441,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))
@@ -417,7 +475,7 @@ class DyadCarrier(object):
 
     def transpose(self):
         """ Returns a deep copy of the transposed DyadCarrier matrix"""
-        return DyadCarrier(self.v, self.u)
+        return DyadCarrier(self.v, self.u, shape=(self.shape[1], self.shape[0]))
 
     def dot(self, other):
         """ Inner product """
@@ -445,9 +503,9 @@ class DyadCarrier(object):
         if other.ndim == 1:
             return self.__dot__(other)
 
-        return DyadCarrier(self.u, [vi@other for vi in self.v])
+        return DyadCarrier(self.u, [vi@other for vi in self.v], shape=(self.shape[0], other.shape[1]))
 
     def __rmatmul__(self, other):  # other @ self
         if other.ndim == 1:
             return self.__rdot__(other)
-        return DyadCarrier([other@ui for ui in self.u], self.v)
+        return DyadCarrier([other@ui for ui in self.u], self.v, shape=(other.shape[0], self.shape[1]))