parallel-sparse-tools 0.1.0__tar.gz

parallel-sparse-tools-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, QuSpin
+
+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 the copyright holder 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.

parallel-sparse-tools-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: parallel-sparse-tools
+Version: 0.1.0
+Summary: My package description
+Author-email: Phillip Weinberg <weinbe58@gmail.com>
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+
+# parallel-sparse-tools
+Repository for OpenMP parallelized Sparse tools

parallel-sparse-tools-0.1.0/README.md

@@ -0,0 +1,2 @@
+# parallel-sparse-tools
+Repository for OpenMP parallelized Sparse tools

parallel-sparse-tools-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["setuptools", "wheel", "Cython", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parallel-sparse-tools"
+version = "0.1.0"
+authors = [
+    {name = "Phillip Weinberg", email = "weinbe58@gmail.com"},
+]
+description = "My package description"
+readme = "README.md"
+requires-python = ">=3.9,<3.13"
+license = {text = "BSD-3-Clause"}
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+]
+
+
+[tool.cibuildwheel]
+skip = ""
+test-skip = ""
+
+build-frontend = "default"
+config-settings = {}
+dependency-versions = "pinned"
+environment = {}
+environment-pass = []
+build-verbosity = 0
+
+before-all = ""
+before-build = ""
+repair-wheel-command = ""
+
+test-command = ""
+before-test = ""
+test-requires = []
+test-extras = []
+
+container-engine = "docker"
+
+manylinux-x86_64-image = "manylinux2014"
+manylinux-i686-image = "manylinux2014"
+manylinux-aarch64-image = "manylinux2014"
+manylinux-ppc64le-image = "manylinux2014"
+manylinux-s390x-image = "manylinux2014"
+manylinux-pypy_x86_64-image = "manylinux2014"
+manylinux-pypy_i686-image = "manylinux2014"
+manylinux-pypy_aarch64-image = "manylinux2014"
+
+musllinux-x86_64-image = "musllinux_1_1"
+musllinux-i686-image = "musllinux_1_1"
+musllinux-aarch64-image = "musllinux_1_1"
+musllinux-ppc64le-image = "musllinux_1_1"
+musllinux-s390x-image = "musllinux_1_1"
+
+
+[tool.cibuildwheel.linux]
+archs = ["x86_64"]
+repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel}"
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]
+repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+[tool.cibuildwheel.windows]
+archs = ["AMD64"]

parallel-sparse-tools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

parallel-sparse-tools-0.1.0/setup.py

@@ -0,0 +1,108 @@
+from setuptools import find_packages, setup, Extension
+from Cython.Build import cythonize
+from typing import List
+import os
+import sys
+import glob
+import subprocess
+import numpy as np
+
+
+def extra_compile_args() -> List[str]:
+    if sys.platform in ["win32", "cygwin", "win64"]:
+        extra_compile_args = ["/openmp"]
+    if sys.platform in ["darwin"]:
+        extra_compile_args = [
+            "-DLLVM_ENABLE_PROJECTS",
+            "-Xpreprocessor",
+            "-fopenmp-version=50"
+            "-fopenmp",
+        ]
+    else:
+        extra_compile_args = ["-fopenmp"]
+
+    return extra_compile_args
+
+
+def extra_link_args() -> List[str]:
+    if sys.platform in ["win32", "cygwin", "win64"]:
+        extra_link_args = ["/openmp"]
+    if sys.platform in ["darwin"]:
+        extra_link_args = [
+            "-DLLVM_ENABLE_PROJECTS",
+            "-Xpreprocessor",
+            "-fopenmp-version=50"
+            "-fopenmp",
+        ]
+    else:
+        extra_link_args = ["-fopenmp"]
+
+    return extra_link_args
+
+
+def matvec_extension() -> List[Extension]:
+    package_path = ("parallel_sparse_tools", "matvec")
+    package_dir = os.path.join("src", *package_path)
+
+    subprocess.check_call(
+        [sys.executable, os.path.join(package_dir, "generate_oputils.py")]
+    )
+
+    includes = [
+        np.get_include(),
+        os.path.join("src", "parallel_sparse_tools", "matvec", "_oputils"),
+    ]
+
+    return generate_extensions(package_path, includes)
+
+
+def expm_multiply_parallel_core_extension() -> List[Extension]:
+    package_path = ("parallel_sparse_tools", "expm_multiply_parallel_core")
+    package_dir = os.path.join("src", *package_path)
+
+    subprocess.check_call(
+        [sys.executable, os.path.join(package_dir, "generate_source.py")]
+    )
+
+    includes = [
+        np.get_include(),
+        os.path.join("src", "parallel_sparse_tools", "matvec", "_oputils"),
+        os.path.join(package_dir, "source"),
+    ]
+
+    return generate_extensions(package_path, includes)
+
+
+def generate_extensions(package_path, includes=[]):
+    package_dir = os.path.join("src", *package_path)
+    cython_src = glob.glob(os.path.join(package_dir, "*.pyx"))
+
+    exts = []
+
+    for cython_file in cython_src:
+        module_name = os.path.split(cython_file)[-1].replace(".pyx", "")
+        module_path = ".".join(package_path + (module_name,))
+
+        exts.append(
+            Extension(
+                module_path,
+                [cython_file],
+                include_dirs=includes,
+                extra_compile_args=extra_compile_args(),
+                extra_link_args=extra_link_args(),
+            )
+        )
+
+    return cythonize(exts, include_path=includes)
+
+
+ext_modules = [
+    *matvec_extension(),
+    *expm_multiply_parallel_core_extension(),
+]
+setup(
+    include_package_data=True,
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    ext_modules=ext_modules,
+)

parallel-sparse-tools-0.1.0/src/parallel_sparse_tools/expm_multiply_parallel_core/__init__.py

@@ -0,0 +1 @@
+from .expm_multiply_parallel_core import ExpmMultiplyParallel

parallel-sparse-tools-0.1.0/src/parallel_sparse_tools/expm_multiply_parallel_core/expm_multiply_parallel_core.py

@@ -0,0 +1,354 @@
+from scipy.sparse.linalg import LinearOperator, onenormest, aslinearoperator
+from .expm_multiply_parallel_wrapper import (
+    _wrapper_expm_multiply,
+    _wrapper_expm_multiply_batch,
+    _wrapper_csr_trace,
+    _wrapper_csr_1_norm,
+)
+from scipy.sparse.construct import eye
+from scipy.sparse.linalg._expm_multiply import _fragment_3_1, _exact_1_norm
+import scipy.sparse as _sp
+import numpy as _np
+
+
+class ExpmMultiplyParallel(object):
+    """Implements `scipy.sparse.linalg.expm_multiply()` for *openmp*.
+
+    Notes
+    -----
+    * this is a wrapper over custom c++ code.
+    * the `dtype` input need not be the same dtype as `A` or `a`; however, it must be possible to cast the result of `a*A` to this `dtype`.
+    * consider the special case of real-time evolution with a purely-imaginary Hamiltonian, in which case `a=-1j*time` and `A` are both complex-valued, while the resulting matrix exponential is real-valued: in such cases, one can use either one of
+
+    >>> expm_multiply_parallel( (1j*H.tocsr()).astype(np.float64), a=-1.0, dtype=np.float64)`
+
+    and
+
+    >>> expm_multiply_parallel( H.tocsr(), a=-1.0j, dtype=np.complex128)
+
+    The more efficient way to compute the matrix exponential in this case is to use a real-valued `dtype`.
+
+
+    Examples
+    --------
+
+    This example shows how to construct the `expm_multiply_parallel` object.
+
+    Further code snippets can be found in the examples for the function methods of the class.
+    The code snippet below initiates the class, and is required to run the example codes for the function methods.
+
+    .. literalinclude:: ../../doc_examples/expm_multiply_parallel-example.py
+        :linenos:
+        :language: python
+        :lines: 7-30
+
+    """
+
+    def __init__(self, A, a=1.0, dtype=None, copy=False):
+        """Initializes `expm_multiply_parallel`.
+
+        Parameters
+        -----------
+        A : {array_like, scipy.sparse matrix}
+            The operator (matrix) whose exponential is to be calculated.
+        a : scalar, optional
+            scalar value multiplying generator matrix :math:`A` in matrix exponential: :math:`\\mathrm{e}^{aA}`.
+        dtype : numpy.dtype, optional
+            data type specified for the total operator :math:`\\mathrm{e}^{aA}`. Default is: `numpy.result_type(A.dtype,min_scalar_type(a),float64)`.
+        copy : bool, optional
+            if `True` the matrix is copied otherwise the matrix is stored by reference.
+
+        """
+        if _np.array(a).ndim == 0:
+            self._a = a
+        else:
+            raise ValueError("a must be scalar value.")
+
+        self._A = _sp.csr_matrix(A, copy=copy)
+
+        if A.shape[0] != A.shape[1]:
+            raise ValueError("A must be a square matrix.")
+
+        a_dtype_min = _np.min_scalar_type(self._a)
+
+        # use double precision by default.
+        if dtype is None:
+            self._dtype = _np.result_type(A.dtype, a_dtype_min, _np.float64)
+        else:
+            min_dtype = _np.result_type(A.dtype, a_dtype_min, _np.float32)
+            if not _np.can_cast(min_dtype, dtype):
+                raise ValueError(
+                    "dtype not sufficient to represent a*A to at least float32 precision."
+                )
+
+            self._dtype = dtype
+
+        tol = _np.finfo(self._dtype).eps / 2
+        tol_dtype = _np.finfo(self._dtype).eps.dtype
+        self._tol = _np.array(tol, dtype=tol_dtype)
+
+        mu = (
+            _wrapper_csr_trace(self._A.indptr, self._A.indices, self._A.data)
+            / self._A.shape[0]
+        )
+        self._mu = _np.array(mu, dtype=self._dtype)
+        self._A_1_norm = _wrapper_csr_1_norm(
+            self._A.indptr, self._A.indices, self._A.data, self._mu
+        )
+        self._calculate_partition()
+
+        # shift = eye(A.shape[0],format="csr",dtype=A.dtype)
+        # shift.data *= mu
+        # self._A = self._A - shift
+
+    @property
+    def a(self):
+        """scalar: value multiplying generator matrix :math:`A` in matrix exponential: :math:`\\mathrm{e}^{aA}`"""
+        return self._a
+
+    @property
+    def A(self):
+        """scipy.sparse.csr_matrix: csr_matrix to be exponentiated."""
+        return self._A
+
+    def set_a(self, a, dtype=None):
+        """Sets the value of the property `a`.
+
+        Parameters
+        ----------
+        a : scalar
+            new value of `a`.
+        dtype : numpy.dtype, optional
+            dtype specified for this operator. Default is: result_type(A.dtype,min_scalar_type(a),float64)
+
+        Examples
+        --------
+
+        .. literalinclude:: ../../doc_examples/expm_multiply_parallel-example.py
+            :linenos:
+            :language: python
+            :lines: 32-35
+
+        """
+
+        if _np.array(a).ndim == 0:
+            self._a = a
+
+            a_dtype_min = _np.min_scalar_type(self._a)
+
+            # use double precision by default.
+            if dtype is None:
+                self._dtype = _np.result_type(self._A.dtype, a_dtype_min, _np.float64)
+            else:
+                min_dtype = _np.result_type(A.dtype, a_dtype_min, _np.float32)
+                if not _np.can_cast(min_dtype, dtype):
+                    raise ValueError(
+                        "dtype not sufficient to represent a*A to at least float32 precision."
+                    )
+
+                self._dtype = dtype
+
+            tol = _np.finfo(self._dtype).eps / 2
+            tol_dtype = _np.finfo(self._dtype).eps.dtype
+            self._tol = _np.array(tol, dtype=tol_dtype)
+            self._mu = _np.array(self._mu, dtype=self._dtype)
+
+            self._calculate_partition()
+        else:
+            raise ValueError("expecting 'a' to be scalar.")
+
+    def dot(self, v, work_array=None, overwrite_v=False, tol=None):
+        """Calculates the action of :math:`\\mathrm{e}^{aA}` on a vector :math:`v`.
+
+        Examples
+        --------
+
+        .. literalinclude:: ../../doc_examples/expm_multiply_parallel-example.py
+            :linenos:
+            :language: python
+            :lines: 37-
+
+        Parameters
+        -----------
+        v : contiguous numpy.ndarray, 1d or 2d array
+            array to apply :math:`\\mathrm{e}^{aA}` on.
+        work_array : contiguous numpy.ndarray, optional
+            array can be any shape but must contain 2*v.size contiguous elements.
+            This array is used as temporary memory space for the underlying c-code. This saves extra memory allocation for function operations.
+        overwrite_v : bool, optoinal
+            if set to `True`, the data in `v` is overwritten by the function. This saves extra memory allocation for the results.
+        tol: float, optoinal
+            tolerance value used to truncate Taylor expansion of matrix exponential.
+
+        Returns
+        --------
+        numpy.ndarray
+            result of :math:`\\mathrm{e}^{aA}v`.
+
+            If `overwrite_v = True` the dunction returns `v` with the data overwritten, otherwise the result is stored in a new array.
+
+        """
+        v = _np.asarray(v)
+
+        if v.ndim > 2:
+            raise ValueError("array must have ndim <= 2.")
+
+        if v.shape[0] != self._A.shape[1]:
+            raise ValueError("dimension mismatch {}, {}".format(self._A.shape, v.shape))
+
+        v_dtype = _np.result_type(self._dtype, v.dtype)
+
+        if overwrite_v:
+            if v_dtype != v.dtype:
+                raise ValueError(
+                    "if overwrite_v is True, the input array must match correct output dtype for matrix multiplication."
+                )
+
+            if not v.flags["CARRAY"]:
+                raise TypeError("input array must a contiguous and writable.")
+
+        else:
+            v = v.astype(v_dtype, order="C", copy=True)
+
+        if work_array is None:
+            if v.ndim == 1:
+                work_array = _np.zeros((2 * self._A.shape[0],), dtype=v.dtype)
+            else:
+                work_array = _np.zeros(
+                    (2 * self._A.shape[0], v.shape[1]), dtype=v.dtype
+                )
+        else:
+            work_array = work_array.ravel(order="A")
+
+            if work_array.size != 2 * v.size:
+                raise ValueError(
+                    "work_array must have twice the number of elements as in v."
+                )
+
+            if work_array.dtype != v_dtype:
+                raise ValueError(
+                    "work_array must be array of dtype which matches the result of the matrix-vector multiplication."
+                )
+
+        a = _np.array(self._a, dtype=v_dtype)
+        mu = _np.array(self._mu, dtype=v_dtype)
+        if tol is not None:
+            tol = _np.array(tol, dtype=mu.real.dtype)
+        else:
+            tol = _np.array(self._tol, dtype=mu.real.dtype)
+        if v.ndim == 1:
+            _wrapper_expm_multiply(
+                self._A.indptr,
+                self._A.indices,
+                self._A.data,
+                self._s,
+                self._m_star,
+                a,
+                tol,
+                mu,
+                v,
+                work_array.ravel(),
+            )
+        else:
+            work_array = work_array.reshape((-1, v.shape[1]))
+            _wrapper_expm_multiply_batch(
+                self._A.indptr,
+                self._A.indices,
+                self._A.data,
+                self._s,
+                self._m_star,
+                a,
+                tol,
+                mu,
+                v,
+                work_array,
+            )
+
+        return v
+
+    def _calculate_partition(self):
+        if _np.abs(self._a) * self._A_1_norm == 0:
+            self._m_star, self._s = 0, 1
+        else:
+            ell = 2
+            norm_info = LazyOperatorNormInfo(
+                self._A, self._A_1_norm, self._a, self._mu, self._dtype, ell=ell
+            )
+            self._m_star, self._s = _fragment_3_1(norm_info, 1, self._tol, ell=ell)
+
+
+##### code below is copied from scipy.sparse.linalg._expm_multiply_core and modified slightly.
+
+
+def matvec_p(v, A, a, mu, p):
+    for i in range(p):
+        v = a * (A.dot(v) - mu * v)
+
+    return v
+
+
+class LazyOperatorNormInfo:
+    """
+    Information about an operator is lazily computed.
+
+    The information includes the exact 1-norm of the operator,
+    in addition to estimates of 1-norms of powers of the operator.
+    This uses the notation of Computing the Action (2011).
+    This class is specialized enough to probably not be of general interest
+    outside of this module.
+
+    """
+
+    def __init__(self, A, A_1_norm, a, mu, dtype, ell=2):
+        """
+        Provide the operator and some norm-related information.
+
+        Parameters
+        -----------
+        A : linear operator
+            The operator of interest.
+        A_1_norm : float
+            The exact 1-norm of A.
+        ell : int, optional
+            A technical parameter controlling norm estimation quality.
+
+        """
+        self._A = A
+        self._a = a
+        self._mu = mu
+        self._dtype = dtype
+        self._A_1_norm = A_1_norm
+        self._ell = ell
+        self._d = {}
+
+    def onenorm(self):
+        """
+        Compute the exact 1-norm.
+        """
+        return _np.abs(self._a) * self._A_1_norm
+
+    def d(self, p):
+        """
+        Lazily estimate d_p(A) ~= || A^p ||^(1/p) where ||.|| is the 1-norm.
+        """
+        if p not in self._d:
+            matvec = lambda v: self._a * (self._A.dot(v) - self._mu * v)
+            rmatvec = lambda v: _np.conj(self._a) * (
+                self._A.H.dot(v) - _np.conj(self._mu) * v
+            )
+            LO = LinearOperator(
+                self._A.shape, dtype=self._dtype, matvec=matvec, rmatvec=rmatvec
+            )
+
+            est = onenormest(LO**p)
+
+            # est = onenormest((self._a * aslinearoperator(self._A))**p)
+            self._d[p] = est ** (1.0 / p)
+
+        return self._d[p]
+
+    def alpha(self, p):
+        """
+        Lazily compute max(d(p), d(p+1)).
+        """
+        return max(self.d(p), self.d(p + 1))