emerge 0.4.11__py3-none-any.whl → 0.5.1__py3-none-any.whl

{emerge-0.4.11.dist-info → emerge-0.5.1.dist-info}/RECORD

@@ -1,27 +1,27 @@
-emerge/__init__.py,sha256=WnFoys_CM_EBaFBf7OprK2QJcBbhparelu1uzP8uBJY,1987
+emerge/__init__.py,sha256=sK2yLrvngIeUOfRJ-YivFP_9J8lbcy-DLZvEI5FBhCc,2559
 emerge/__main__.py,sha256=WVf16sfrOI910QWohrQDaChZdRifMNoS6VKzCT6f3ZA,92
 emerge/cli.py,sha256=xrNPoX5VtUA0KPRRwZPxC0rGtBDKc2FF8Ro-uPuO-Hg,665
-emerge/lib.py,sha256=usURQQhFdk5oSmcbr6AAUT50-Z-k6jnePdE3BdvUaYY,2548
+emerge/lib.py,sha256=uOvBbOtPkwXjLygzs-s7Wf-2oM1YfCPGiz1E2UkVXgU,17869
 emerge/plot.py,sha256=AH2D9rKeWUXlSOlh-pUUfLt0oxVLcqF_piki-BmPEg0,83
 emerge/pyvista.py,sha256=-Ht2YcZYsh8-dici5ZPNAWwsis6uz5wNj8n8mxv5fog,42
 emerge/_emerge/__init__.py,sha256=hYCXbPCoyjAc3EUsYc4yz8ct6crlYHB9B02o_Am9ITs,1646
-emerge/_emerge/bc.py,sha256=NqbTEP6ayZPx3j1vJNup64lWcQOcGikOgs0ndvOVZdw,7288
+emerge/_emerge/bc.py,sha256=J-Axq-oWcCL_n_4cee3z3hPV67Typ6o4_9o9PFLEZJ4,8488
 emerge/_emerge/coord.py,sha256=BKvyrcnHY-_bgHqysnByy5k9_DK4VVfr9KKkRaawG2E,4371
 emerge/_emerge/cs.py,sha256=ncpedffKF9cJFm0DE_7FOQrHngxLhIv9ciV1-uR-TTw,17880
 emerge/_emerge/dataset.py,sha256=UcSAJ_siLrOjNBBWRWsS3GUZUpayp63EM6pP6ClwKDI,1534
 emerge/_emerge/geo2d.py,sha256=e_HkX1GQ2iYrdO0zeEgzVOzfGyU1WGJyjeGBAobOttE,3323
 emerge/_emerge/geometry.py,sha256=gWLdmkP4Sb-OHinCSuXiNw1BV7hQ8_zmo0PrcfEJXEA,16784
-emerge/_emerge/howto.py,sha256=63AwiLbBN0aou12qDOhWuPk7GiBmDySixv5xmRzctV8,8208
-emerge/_emerge/logsettings.py,sha256=eq0hIikrtx4TLFx3W1qlV5CpcH2JRForQb9fi6eXXGI,144
+emerge/_emerge/howto.py,sha256=qY3v6DynB9ZBVeYa3sPFq1cDuvf2zyjnLShknqYyvKQ,8208
+emerge/_emerge/logsettings.py,sha256=0iwTLwyGebBxDCGYMsLfoouQ8Ze2qrF2n0Iqv7FYD0w,2654
 emerge/_emerge/material.py,sha256=8c3bEov76xqpH1w9s3ZGZ47EuofUNjVeI_IO4RG15Rk,3879
-emerge/_emerge/mesh3d.py,sha256=bHy3YxshTFDmzb816udcF0NfKClCHucSx7YAyfMu9cQ,29874
+emerge/_emerge/mesh3d.py,sha256=5dGayT9HWDe7STn0_ZofXtmvthZypR57b7YmIBeI8Yg,30759
 emerge/_emerge/mesher.py,sha256=cYq6AS1xUWpCrx3JCml5OCoDwNR0Z6FnFFOcH7QoSa4,12654
-emerge/_emerge/periodic.py,sha256=s6B6-zQQ_7MZ4tNRd2a1jzTR3p-RGCW0Y97vLGwirco,9874
+emerge/_emerge/periodic.py,sha256=oKYa3P_PREngrWwhwTpCSVYeo7JT7KjM9GuW1lY-0h0,10613
 emerge/_emerge/plot.py,sha256=cf1I9mj7EIUJcq8vmANlUkqoV6QqVaJaP-zlC-T9E18,8041
 emerge/_emerge/selection.py,sha256=HoRILOW52pJG1griLqdI5NsIEa3kwB0lsSojVcWtaBA,21087
-emerge/_emerge/simmodel.py,sha256=xlQoS1ecj7w1vXHI_X5NRpvkqDTqOSAbpt5vUIQK1-w,17300
+emerge/_emerge/simmodel.py,sha256=6qxuNvjBnY4PI0R8xMTfinXgkAnSyD1eHTDKhaCiC00,17816
 emerge/_emerge/simulation_data.py,sha256=E3567Ro1YxQlidwZrc5G8IxG46Gnfy-k0wYWxckt1Iw,14128
-emerge/_emerge/solver.py,sha256=LjFEYMQYl1vnbVg_gd8HW5o_YhWjXHccIaJHJpX1gXU,37943
+emerge/_emerge/solver.py,sha256=zkyYlykaDmuRy8VoQo3Z6tWi4cQtbUXY7ph0PclXOLc,40403
 emerge/_emerge/system.py,sha256=p4HNz7d_LMRNE9Gk75vVdFecDH2iN_groAM9u-yQTpk,1618
 emerge/_emerge/elements/__init__.py,sha256=I3n9aic6lJW-oGeqTEZ-Fpxvyl2i-WqsHdnrM3v1oB8,799
 emerge/_emerge/elements/femdata.py,sha256=Gul5JJQq_gEDjFyf9RwLU-E7Aoh7hIpmrR7nL8SX4Hg,7893
@@ -30,36 +30,37 @@ emerge/_emerge/elements/legrange2.py,sha256=6pqQ6O8FyFBWCPwtvSN5yRxUG3L6pgGssw4B
 emerge/_emerge/elements/ned2_interp.py,sha256=w7L8E_ksTjKHaJfVlelfNLIZTXACcb3fDmquYWlHIZY,27264
 emerge/_emerge/elements/nedelec2.py,sha256=lzjGxKYq02DJ0AX4m3rX690Ve1MP-70mSQ462yrJZ20,6110
 emerge/_emerge/elements/nedleg2.py,sha256=Hn_Vh8aRL1740-i1nKu-VdwgLLRZINPHLbQPKSGci5Y,9415
-emerge/_emerge/geo/__init__.py,sha256=Ro1HsAKjy5EIIBmrPRZnzPwxvmIONUhq9KbW6fNfQT4,1110
+emerge/_emerge/geo/__init__.py,sha256=ERmbdr8NUnDQWK-E-Bbc4Kl8AQczjpIP5BnwtZmcurE,1102
 emerge/_emerge/geo/horn.py,sha256=eIGzjTa3AmhOXT3cSlPetDlW-l1PR-hG6zjSc6dCrz0,4171
 emerge/_emerge/geo/modeler.py,sha256=s7JaizoqByT_YLSXw0h4o8sBlPDoZZW5iGOCJHqoYJo,15382
 emerge/_emerge/geo/operations.py,sha256=7IPuuI0xZB8eTaJhaJjn9m48uyTS95FM78vO9GaF21I,9516
-emerge/_emerge/geo/pcb.py,sha256=vzOBcUwxmihFKEk7UwPQWSVz2Jryj697WcsO82U4Xok,46119
+emerge/_emerge/geo/pcb.py,sha256=nm9FKP_B97bFPRLa20vbRc23m0xxUK4djjQ_Kp855K4,47577
 emerge/_emerge/geo/pmlbox.py,sha256=i9Ejxfwu3tZ4DOx4Ru5-FHX7f4rULy291z-119up-O4,7892
 emerge/_emerge/geo/polybased.py,sha256=4J5ExvL-yw4NtA1ZZfIYdj3J5g0vpzq_nlCsIjFQFBU,19473
 emerge/_emerge/geo/shapes.py,sha256=TTdlHG-OPogS19UCt6EeZqb8tb7WxZ6ZZHxBHIOrKuQ,17206
 emerge/_emerge/geo/step.py,sha256=XcAiEN8W4umNmZdYmrGHX_aJUuiMgc6vgT-UIk8Gbqc,2689
 emerge/_emerge/geo/pcb_tools/calculator.py,sha256=oumN7-0kejVDxZklE_JTnrDt5ywaHv_2Ef6D7mNABbc,812
 emerge/_emerge/geo/pcb_tools/macro.py,sha256=ZlKDIZQTXjgklUJZVkaDa17eHIfo9ssq1jXouOSqSUU,2865
-emerge/_emerge/mth/common_functions.py,sha256=23_5QpwvoCSTHSkRVuDJlE1ANEPMSe6hSAH56aEmcxc,1233
-emerge/_emerge/mth/integrals.py,sha256=E-vfe21_VGlyJRhqNADdALUhXIKPrwuekTo4GwUyZGA,2702
-emerge/_emerge/mth/optimized.py,sha256=oI3D_hUZXSUMGODMdyY9NZggV2Y7YP5Ky09ZmO4VMZ8,13710
-emerge/_emerge/pardiso/pardiso_solver.py,sha256=u3qCr4wXmUA7MZjTCDMq_2Ho3YWjtlelUQtFuBEPe2s,19043
+emerge/_emerge/mth/common_functions.py,sha256=oURfF-8p_0s1dKbUATc15dnKHFwvqWa6GC-JMW9UwnI,2061
+emerge/_emerge/mth/integrals.py,sha256=Ypmd1r0CDQHQ-kWKdfhY_nypDDzTpTcTKpNdBeHieps,3565
+emerge/_emerge/mth/optimized.py,sha256=K0YQ_faD6aETox2HKYlIIUJElqaGc8zrYEI9SedpQCc,16493
+emerge/_emerge/mth/pairing.py,sha256=xNz_t1Vbxz5e8XsBW4JolRWPa_VTr2Gf1rW1G9lqfRo,3515
 emerge/_emerge/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/physics/microwave/__init__.py,sha256=QHeILGYWmvbfLl1o9wrTiWLm0evfXDgS0JiikUoMTts,28
 emerge/_emerge/physics/microwave/adaptive_freq.py,sha256=5Ph2V4TTDjrFMeI7MI20JID9BNUNQ_ygtDSHj5Bkpmw,9736
-emerge/_emerge/physics/microwave/microwave_3d.py,sha256=X4hR1wKpnp0BEYj7zkgnDyFgqPX4BIugJokHAeoTwQU,46966
-emerge/_emerge/physics/microwave/microwave_bc.py,sha256=ko1yCzbJgoXoQ2QYtzWblCDFkraZsbMDrW6VhtvHMxo,35585
-emerge/_emerge/physics/microwave/microwave_data.py,sha256=jm2PZu4zjcWn6caof4y0xa5wFlFkkYZ58PTxq-1m3tY,43691
+emerge/_emerge/physics/microwave/microwave_3d.py,sha256=4Ffe7KfyvmndVYIrv2IMA9yczU1Efoo8OrHbTpJtHJE,47034
+emerge/_emerge/physics/microwave/microwave_bc.py,sha256=7nTlrVzOFNxfFdOZKcF9R7AGmB5K_ssKDte8DL7HNO4,35527
+emerge/_emerge/physics/microwave/microwave_data.py,sha256=CBG3sLoKXaR6wBdFl-dv6tDVY1_OI3m6FAYt9iCAw4I,43695
 emerge/_emerge/physics/microwave/periodic.py,sha256=wYSUgLFVtCLqSG3EDKoCDRU93iPUzBdXzVRdHTRmbpI,3000
 emerge/_emerge/physics/microwave/port_functions.py,sha256=aVU__AkVk8b1kH2J_oDLF5iNReCxC9nzCtesFSSSSQo,2112
 emerge/_emerge/physics/microwave/sc.py,sha256=EjbbHEZ1zc42V0s8ItrN8jIXkrg3N5R495gfurZ2Wck,4992
 emerge/_emerge/physics/microwave/simjob.py,sha256=DzkniH4yVi_dYyLuKVzMnvve8u-HtOKoXkaF1kUplRo,4678
-emerge/_emerge/physics/microwave/sparam.py,sha256=zdT06pvEr70TFiQNzaCDW0f38d1V19safCZG8jW1csw,4953
+emerge/_emerge/physics/microwave/sparam.py,sha256=9bbnuJhdhwUlqf2kehZ_R9ieFN6toUUqW_ppULLhpV0,4959
 emerge/_emerge/physics/microwave/touchstone.py,sha256=I1gtdCv3FYaYjhWQRgjIp-QSS9caTD-axkbiO-48E4E,5792
-emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=YbqleOK6WEwZtRXiWCkPL822YHWZYPVfGvZ9ZzXDa1U,20416
-emerge/_emerge/physics/microwave/assembly/curlcurl.py,sha256=hgDvUEzqSswaZAHa5fJoOY37_AHInZJQ9Jr7k0zlT9I,17822
+emerge/_emerge/physics/microwave/assembly/assembler.py,sha256=oIlH8aJWD0kb5KPzHXT45e01xExpY6H0E43GVEBFSUQ,20573
+emerge/_emerge/physics/microwave/assembly/curlcurl.py,sha256=fO1r1lyPF5U3UvlQg2Zg1gnnpODrWIv-qVEYDWYXqgM,18976
 emerge/_emerge/physics/microwave/assembly/generalized_eigen.py,sha256=wtLKCndYgqKLCH0mSni9bu8yhnPi9ksIAafvToyy2TQ,16171
+emerge/_emerge/physics/microwave/assembly/periodicbc.py,sha256=Zg1kgQMccDQA2oVErpfldv6v2oYfc9Y3xWcpfg93-FY,4646
 emerge/_emerge/physics/microwave/assembly/robinbc.py,sha256=tJg5GzOGuNybu5qdtOuIgcpem6IVAMrPFre_SENLg44,16246
 emerge/_emerge/plot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 emerge/_emerge/plot/display.py,sha256=akwFUOgVEZEIyY6eo05jeFgNvKXy41blwpHohAtn8OM,18247
@@ -70,11 +71,12 @@ emerge/_emerge/plot/pyvista/__init__.py,sha256=CPclatEu6mFnJZzCQk09g6T6Fh20WTbiL
 emerge/_emerge/plot/pyvista/display.py,sha256=PJnM5yDSYrTPT0Ts7Sia2LOkaSs8h1Mj_Gt7q9lF-i4,32908
 emerge/_emerge/plot/pyvista/display_settings.py,sha256=OFxZWasZ-AN71l41rRybTb_mn2z5rFfdusqRXDCJr-w,848
 emerge/_emerge/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emerge/_emerge/projects/_gen_base.txt,sha256=oQ1y985IeqLo4T7jmKiXLUukn2rSMXfXQS09FoYOqkk,607
+emerge/_emerge/projects/_gen_base.txt,sha256=_4McYD9Sb1KWRsrGV51mNNAJNYkjm_IemMnCdAsGuLo,607
 emerge/_emerge/projects/_load_base.txt,sha256=JTAhWvHXJQYKe-aDD4HDdmE7f3VXxeurhDzwFCegrEg,511
 emerge/_emerge/projects/generate_project.py,sha256=TNw-0SpLc82MBq0bd9hB_yqvBZCgmuPonCBsHTp91uk,1450
-emerge-0.4.11.dist-info/METADATA,sha256=GSNdpruqnvbva-q-O6S8vae9jRXJ4JLa15TK24azZJI,2901
-emerge-0.4.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emerge-0.4.11.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
-emerge-0.4.11.dist-info/licenses/LICENSE,sha256=6tAv8fkWA_-Ell_nboaXajWH3H-vRftIr_4CU2t0S4Y,15180
-emerge-0.4.11.dist-info/RECORD,,
+emerge/_emerge/solve_interfaces/pardiso_interface.py,sha256=3fMRzAQgi9hcP4xLwF-Uqnw8a7rv9RY_ckxc2M2qLQ4,15173
+emerge-0.5.1.dist-info/METADATA,sha256=0U-pN9h-zb8VCt0LKDEZuNUGluWG9buqY2aO9RARyLg,2900
+emerge-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emerge-0.5.1.dist-info/entry_points.txt,sha256=8rFvAXticpKg4OTC8JEvAksnduW72KIEskCGG9XnFf8,43
+emerge-0.5.1.dist-info/licenses/LICENSE,sha256=6tAv8fkWA_-Ell_nboaXajWH3H-vRftIr_4CU2t0S4Y,15180
+emerge-0.5.1.dist-info/RECORD,,

emerge/_emerge/pardiso/pardiso_solver.py

@@ -1,455 +0,0 @@
-# Copyright (c) 2016 Adrian Haas and ETH Zürich
-# Modifications Copyright (c) 2025 Robert Fennis
-#
-# SPDX-License-Identifier: BSD-3-Clause AND GPL-2.0-or-later
-#
-# This file incorporates code from the PyPardiso project, which is
-# distributed under the BSD 3-Clause License.  You may redistribute
-# and/or modify this file under either
-#
-#   * the terms of the BSD 3-Clause License (see below), or
-#   * the terms of the GNU General Public License, version 2 or later.
-#
-# ----------------------------------------------------------------------
-# BSD 3-Clause License
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-# 3. Neither the name of ETH Zürich nor the names of its contributors
-#    may be used to endorse or promote products derived from this
-#    software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-# DAMAGE.
-# ----------------------------------------------------------------------
-
-# coding: utf-8
-import scipy.sparse as sp
-# coding: utf-8
-import os
-import sys
-import glob
-import ctypes
-import warnings
-import hashlib
-import site
-from ctypes.util import find_library
-
-import numpy as np
-import scipy.sparse as sp
-from scipy.sparse import SparseEfficiencyWarning, csr_matrix
-
-
-_PARDISO_ERROR_CODES = """
-   0 | No error.
-  -1 | Input inconsistent.
-  -2 | Not enough memory.
-  -3 | Reordering problem.
-  -4 | Zero pivot, numerical fac. or iterative refinement problem.
-  -5 | Unclassified (internal) error.
-  -6 | Preordering failed (matrix types 11(real and nonsymmetric), 13(complex and nonsymmetric) only).
-  -7 | Diagonal Matrix problem.
-  -8 | 32-bit integer overflow problem.
- -10 | No license file pardiso.lic found.
- -11 | License is expired.
- -12 | Wrong username or hostname.
--100 | Reached maximum number of Krylov-subspace iteration in iterative solver.
--101 | No sufficient convergence in Krylov-subspace iteration within 25 iterations.
--102 | Error in Krylov-subspace iteration.
--103 | Bread-Down in Krylov-subspace iteration
-"""
-
-class MKL_Complex16(ctypes.Structure):
-    _fields_ = [("real", ctypes.c_double),
-                ("imag", ctypes.c_double)]
-
-cpx16_p = ctypes.POINTER(MKL_Complex16)
-
-class PyPardisoSolver:
-    """
-    Python interface to the Intel MKL PARDISO library for solving large sparse linear systems of equations Ax=b.
-
-    Pardiso documentation: https://software.intel.com/en-us/node/470282
-
-    --- Basic usage ---
-    matrix type: real (float64) and nonsymetric
-    methods: solve, factorize
-
-    - use the "solve(A,b)" method to solve Ax=b for x, where A is a sparse CSR (or CSC) matrix and b is a numpy array
-    - use the "factorize(A)" method first, if you intend to solve the system more than once for different right-hand
-      sides, the factorization will be reused automatically afterwards
-
-
-    --- Advanced usage ---
-    methods: get_iparm, get_iparms, set_iparm, set_matrix_type, set_phase
-
-    - additional options can be accessed by setting the iparms (see Pardiso documentation for description)
-    - other matrix types can be chosen with the "set_matrix_type" method. complex matrix types are currently not
-      supported. pypardiso is only teste for mtype=11 (real and nonsymetric)
-    - the solving phases can be set with the "set_phase" method
-    - The out-of-core (OOC) solver either fails or crashes my computer, be careful with iparm[60]
-
-
-    --- Statistical info ---
-    methods: set_statistical_info_on, set_statistical_info_off
-
-    - the Pardiso solver writes statistical info to the C stdout if desired
-    - if you use pypardiso from within a jupyter notebook you can turn the statistical info on and capture the output
-      real-time by wrapping your call to "solve" with wurlitzer.sys_pipes() (https://github.com/minrk/wurlitzer,
-      https://pypi.python.org/pypi/wurlitzer/)
-    - wurlitzer dosen't work on windows, info appears in notebook server console window if used from jupyter notebook
-
-
-    --- Memory usage ---
-    methods: remove_stored_factorization, free_memory
-
-    - remove_stored_factorization can be used to delete the wrapper's copy of matrix A
-    - free_memory releases the internal memory of the solver
-
-    """
-
-    def __init__(self, mtype=11, phase=13, size_limit_storage=5e7):
-
-        self.libmkl = None
-
-        # custom mkl_rt path in environment variable
-        mkl_rt = os.environ.get('PYPARDISO_MKL_RT')
-
-        # Look for the mkl_rt shared library with ctypes.util.find_library
-        if mkl_rt is None:
-            mkl_rt = find_library('mkl_rt')
-        # also look for mkl_rt.1, Windows-specific, see
-        # https://github.com/haasad/PyPardisoProject/issues/12
-        if mkl_rt is None:
-            mkl_rt = find_library('mkl_rt.1')
-
-        # If we can't find mkl_rt with find_library, we search the directory
-        # tree, using a few assumptions:
-        # - the shared library can be found in a subdirectory of sys.prefix
-        #   https://docs.python.org/3.9/library/sys.html#sys.prefix
-        #   or in the user site in case of user-local installation like
-        #   `pip install --user`
-        #   https://peps.python.org/pep-0370/
-        #   https://docs.python.org/3/library/site.html#site.USER_BASE
-        # - either in `lib` (linux and macOS) or `Library\bin` (windows)
-        # - if there are multiple matches for `mkl_rt`, try shorter paths
-        #   first
-        if mkl_rt is None:
-            globs = glob.glob(
-                f'{sys.prefix}/[Ll]ib*/**/*mkl_rt*', recursive=True
-            ) or glob.glob(
-                f'{site.USER_BASE}/[Ll]ib*/**/*mkl_rt*', recursive=True
-            )
-            for path in sorted(globs, key=len):
-                try:
-                    self.libmkl = ctypes.CDLL(path)
-                    break
-                except (OSError, ImportError):
-                    pass
-
-            if self.libmkl is None:
-                raise ImportError(
-                    'Shared library mkl_rt not found. '
-                    'Use environment variable PYPARDISO_MKL_RT to provide a custom path.'
-                )
-        else:
-            self.libmkl = ctypes.CDLL(mkl_rt)
-
-        self._mkl_pardiso = self.libmkl.pardiso
-
-        # determine 32bit or 64bit architecture
-        if ctypes.sizeof(ctypes.c_void_p) == 8:
-            self._pt_type = (ctypes.c_int64, np.int64)
-        else:
-            self._pt_type = (ctypes.c_int32, np.int32)
-
-        self._mkl_pardiso.argtypes = [ctypes.POINTER(self._pt_type[0]),    # pt
-                                      ctypes.POINTER(ctypes.c_int32),      # maxfct
-                                      ctypes.POINTER(ctypes.c_int32),      # mnum
-                                      ctypes.POINTER(ctypes.c_int32),      # mtype
-                                      ctypes.POINTER(ctypes.c_int32),      # phase
-                                      ctypes.POINTER(ctypes.c_int32),      # n
-                                      ctypes.POINTER(None),                # a
-                                      ctypes.POINTER(ctypes.c_int32),      # ia
-                                      ctypes.POINTER(ctypes.c_int32),      # ja
-                                      ctypes.POINTER(ctypes.c_int32),      # perm
-                                      ctypes.POINTER(ctypes.c_int32),      # nrhs
-                                      ctypes.POINTER(ctypes.c_int32),      # iparm
-                                      ctypes.POINTER(ctypes.c_int32),      # msglvl
-                                      ctypes.POINTER(None),                # b
-                                      ctypes.POINTER(None),                # x
-                                      ctypes.POINTER(ctypes.c_int32)]      # error
-
-        self._mkl_pardiso.restype = None
-
-        self.pt = np.zeros(64, dtype=self._pt_type[1])
-        self.iparm = np.zeros(64, dtype=np.int32)
-        self.perm = np.zeros(0, dtype=np.int32)
-
-        self.mtype = mtype
-        self.phase = phase
-        self.msglvl = False
-
-        self.factorized_A = csr_matrix((0, 0))
-        self.size_limit_storage = size_limit_storage
-        self._solve_transposed = False
-
-    def factorize(self, A):
-        """
-        Factorize the matrix A, the factorization will automatically be used if the same matrix A is passed to the
-        solve method. This will drastically increase the speed of solve, if solve is called more than once for the
-        same matrix A
-
-        --- Parameters ---
-        A: sparse square CSR matrix (scipy.sparse.csr.csr_matrix), CSC matrix also possible
-        """
-
-        self._check_A(A)
-
-        if A.nnz > self.size_limit_storage:
-            self.factorized_A = self._hash_csr_matrix(A)
-        else:
-            self.factorized_A = A.copy()
-
-        self.set_phase(12)
-        b = np.zeros((A.shape[0], 1))
-        self._call_pardiso(A, b)
-
-    def solve(self, A, b):
-        """
-        solve Ax=b for x
-
-        --- Parameters ---
-        A: sparse square CSR matrix (scipy.sparse.csr.csr_matrix), CSC matrix also possible
-        b: numpy ndarray
-           right-hand side(s), b.shape[0] needs to be the same as A.shape[0]
-
-        --- Returns ---
-        x: numpy ndarray
-           solution of the system of linear equations, same shape as input b
-        """
-
-        self._check_A(A)
-        b = self._check_b(A, b)
-
-        if self._is_already_factorized(A):
-            self.set_phase(33)
-        else:
-            self.set_phase(13)
-
-        x = self._call_pardiso(A, b)
-
-        # it is possible to call the solver with empty columns, but computationally expensive to check this
-        # beforehand, therefore only the result is checked for infinite elements.
-        # if not np.isfinite(x).all():
-        #    warnings.warn('The result contains infinite elements. Make sure that matrix A contains no empty columns.',
-        #                  PyPardisoWarning)
-        # --> this check doesn't work consistently, maybe add an advanced input check method for A
-
-        return x
-
-    def _is_already_factorized(self, A):
-        if isinstance(self.factorized_A, str):
-            return self._hash_csr_matrix(A) == self.factorized_A
-        else:
-            return self._csr_matrix_equal(A, self.factorized_A)
-
-    def _csr_matrix_equal(self, a1, a2):
-        return all((np.array_equal(a1.indptr, a2.indptr),
-                    np.array_equal(a1.indices, a2.indices),
-                    np.array_equal(a1.data, a2.data)))
-
-    def _hash_csr_matrix(self, matrix):
-        return (hashlib.sha1(matrix.indices).hexdigest() +
-                hashlib.sha1(matrix.indptr).hexdigest() +
-                hashlib.sha1(matrix.data).hexdigest())
-
-    def _check_A(self, A):
-        if A.shape[0] != A.shape[1]:
-            raise ValueError('Matrix A needs to be square, but has shape: {}'.format(A.shape))
-
-        if sp.issparse(A) and A.format == "csr":
-            self._solve_transposed = False
-            self.set_iparm(12, 1)
-        elif sp.issparse(A) and A.format == "csc":
-            self._solve_transposed = True
-            self.set_iparm(12, 0)
-        else:
-            msg = 'PyPardiso requires matrix A to be in CSR or CSC format, but matrix A is: {}'.format(type(A))
-            raise TypeError(msg)
-
-        # scipy allows unsorted csr-indices, which lead to completely wrong pardiso results
-        if not A.has_sorted_indices:
-            A.sort_indices()
-
-        # scipy allows csr matrices with empty rows. a square matrix with an empty row is singular. calling
-        # pardiso with a matrix A that contains empty rows leads to a segfault, same applies for csc with
-        # empty columns
-        if not np.diff(A.indptr).all():
-            row_col = 'column' if self._solve_transposed else 'row'
-            raise ValueError('Matrix A is singular, because it contains empty {}(s)'.format(row_col))
-
-    def _check_b(self, A, b):
-        if sp.issparse(b):
-            warnings.warn('PyPardiso requires the right-hand side b to be a dense array for maximum efficiency',
-                          SparseEfficiencyWarning)
-            b = b.todense()
-
-        # pardiso expects fortran (column-major) order for b
-        if not b.flags.f_contiguous:
-            b = np.asfortranarray(b)
-
-        if b.shape[0] != A.shape[0]:
-            raise ValueError("Dimension mismatch: Matrix A {} and array b {}".format(A.shape, b.shape))
-
-        if b.dtype != np.float64:
-            if b.dtype in [np.float16, np.float32, np.int16, np.int32, np.int64]:
-                warnings.warn("Array b's data type was converted from {} to float64".format(str(b.dtype)),
-                              PyPardisoWarning)
-                b = b.astype(np.float64)
-            elif b.dtype in (np.complex128, np.complex64):
-                b = b.astype(np.complex128)
-            else:
-                raise TypeError('Dtype {} for array b is not supported'.format(str(b.dtype)))
-
-        return b
-
-    def _call_pardiso(self, A, b):
-        self.set_iparm(2,3)
-        self.set_iparm(3,6)
-        self.set_iparm(10,13)
-        self.set_iparm(13,2)
-
-        x = np.zeros_like(b)
-        pardiso_error = ctypes.c_int32(0)
-        c_int32_p = ctypes.POINTER(ctypes.c_int32)
-        c_float64_p = ctypes.POINTER(ctypes.c_double)
-
-        # 1-based indexing
-        ia = A.indptr + 1
-        ja = A.indices + 1
-
-        mtype = 3
-        
-        if A.dtype == np.complex128:
-            val_ptr = A.data.ctypes.data_as(cpx16_p)
-            rhs_ptr = b.ctypes.data_as(cpx16_p)
-            x_ptr = x.ctypes.data_as(cpx16_p)
-        else:
-            val_ptr = A.data.ctypes.data_as(c_float64_p)
-            rhs_ptr = b.ctypes.data_as(c_float64_p)
-            x_ptr = x.ctypes.data_as(c_float64_p)
-
-        self._mkl_pardiso(self.pt.ctypes.data_as(ctypes.POINTER(self._pt_type[0])),  # pt
-                          ctypes.byref(ctypes.c_int32(1)),  # maxfct
-                          ctypes.byref(ctypes.c_int32(1)),  # mnum
-                          ctypes.byref(ctypes.c_int32(mtype)),  # mtype -> 11 for real-nonsymetric
-                          ctypes.byref(ctypes.c_int32(self.phase)),  # phase -> 13
-                          ctypes.byref(ctypes.c_int32(A.shape[0])),  # N -> number of equations/size of matrix
-                          val_ptr,  # A -> non-zero entries in matrix
-                          ia.ctypes.data_as(c_int32_p),  # ia -> csr-indptr
-                          ja.ctypes.data_as(c_int32_p),  # ja -> csr-indices
-                          self.perm.ctypes.data_as(c_int32_p),  # perm -> empty
-                          ctypes.byref(ctypes.c_int32(1 if b.ndim == 1 else b.shape[1])),  # nrhs
-                          self.iparm.ctypes.data_as(c_int32_p),  # iparm-array
-                          ctypes.byref(ctypes.c_int32(self.msglvl)),  # msg-level -> 1: statistical info is printed
-                          rhs_ptr,  # b -> right-hand side vector/matrix
-                          x_ptr,  # x -> output
-                          ctypes.byref(pardiso_error))  # pardiso error
-
-        if pardiso_error.value != 0:
-            raise PyPardisoError(pardiso_error.value)
-        else:
-            return np.ascontiguousarray(x)  # change memory-layout back from fortran to c order
-
-    def get_iparms(self):
-        """Returns a dictionary of iparms"""
-        return dict(enumerate(self.iparm, 1))
-
-    def get_iparm(self, i):
-        """Returns the i-th iparm (1-based indexing)"""
-        return self.iparm[i-1]
-
-    def set_iparm(self, i, value):
-        """set the i-th iparm to 'value' (1-based indexing)"""
-        if i not in {1, 2, 3, 4, 5, 6, 8, 10, 11, 12, 13, 18, 19, 21, 24, 25, 27, 28, 31, 34, 35, 36, 37, 56, 60}:
-            warnings.warn('{} is no input iparm. See the Pardiso documentation.'.format(value), PyPardisoWarning)
-        self.iparm[i-1] = value
-
-    def set_matrix_type(self, mtype):
-        """Set the matrix type (see Pardiso documentation)"""
-        self.mtype = mtype
-
-    def set_statistical_info_on(self):
-        """Display statistical info (appears in notebook server console window if pypardiso is
-        used from jupyter notebook, use wurlitzer to redirect info to the notebook)"""
-        self.msglvl = 1
-
-    def set_statistical_info_off(self):
-        """Turns statistical info off"""
-        self.msglvl = 0
-
-    def set_phase(self, phase):
-        """Set the phase(s) for the solver. See the Pardiso documentation for details."""
-        self.phase = phase
-
-    def remove_stored_factorization(self):
-        """removes the stored factorization, this will free the memory in python, but the factorization in pardiso
-        is still accessible with a direct call to self._call_pardiso(A,b) with phase=33"""
-        self.factorized_A = sp.csr_matrix((0, 0))
-
-    def free_memory(self, everything=False):
-        """release mkl's internal memory, either only for the factorization (ie the LU-decomposition) or all of
-        mkl's internal memory if everything=True"""
-        self.remove_stored_factorization()
-        A = sp.csr_matrix((0, 0))
-        b = np.zeros(0)
-        self.set_phase(-1 if everything else 0)
-        self._call_pardiso(A, b)
-        self.set_phase(13)
-
-    def pardiso_solve(self, A: csr_matrix, b: np.ndarray):
-        if sp.issparse(A) and A.format == "csc":
-            A = A.tocsr()  
-
-        self._check_A(A)
-
-        if not self._is_already_factorized(A):
-            self.factorize(A)
-
-        try:
-            x = self.solve(A, b)
-        except PyPardisoError as e:
-            print('Error Codes:')
-            print(_PARDISO_ERROR_CODES)
-
-        return x.squeeze()
-
-class PyPardisoWarning(UserWarning):
-    pass
-
-
-class PyPardisoError(Exception):
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return ('The Pardiso solver failed with error code {}. '
-                'See Pardiso documentation for details.'.format(self.value))