redbirdpy 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

redbirdpy/__init__.py

@@ -52,7 +52,7 @@ Author: Translated from Redbird MATLAB toolbox by Qianqian Fang (q.fang <at> neu
 License: GPL version 3
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __author__ = "Qianqian Fang"
 
 from . import forward

redbirdpy/solver.py

@@ -3,11 +3,11 @@ Redbird Solver Module - Linear system solvers for FEM.
 
 Provides:
     femsolve: Main solver interface with automatic method selection
-    get_solver_info: Query available solver backends
+    solverinfo: Query available solver backends
 
 Supported solvers:
     Direct: pardiso, umfpack, cholmod, superlu
-    Iterative: blqmr, cg, cg+amg, gmres, bicgstab
+    Iterative: blqmr, cg, cg+amg, gmres, bicgstab, qmr, minres
 
 Dependencies:
     - blocksolver: For BLQMR iterative solver (complex symmetric systems)
@@ -15,16 +15,17 @@ Dependencies:
 
 __all__ = [
     "femsolve",
-    "get_solver_info",
+    "solverinfo",
 ]
 
 import numpy as np
 from scipy import sparse
-from scipy.sparse.linalg import spsolve, cg, gmres, bicgstab, splu
+from scipy.sparse.linalg import spsolve, cg, gmres, bicgstab, qmr, minres, splu
 from typing import Dict, Tuple, Optional, Union, List, Any
 import warnings
-from concurrent.futures import ProcessPoolExecutor
+from multiprocessing import Pool
 import multiprocessing
+import sys
 
 # =============================================================================
 # Solver Backend Detection
@@ -40,6 +41,21 @@ _HAS_BLQMR = False
 _pardiso_solve = None
 _pardiso_factorized = None
 
+
+# Multiprocessing context - use 'spawn' for Python 3.14+ compatibility
+# 'spawn' is safer and more portable, but 'fork' is faster on Unix (Python < 3.14)
+def _get_mp_context():
+    """Get appropriate multiprocessing context based on Python version and platform."""
+    # Python 3.14+ or macOS: always use spawn for safety
+    if sys.version_info >= (3, 14) or sys.platform == "darwin":
+        return multiprocessing.get_context("spawn")
+    # Older Python on Linux: try fork first (faster), fallback to spawn
+    try:
+        return multiprocessing.get_context("fork")
+    except ValueError:
+        return multiprocessing.get_context("spawn")
+
+
 try:
     from pypardiso import spsolve as pardiso_solve, factorized as pardiso_factorized
 
@@ -121,11 +137,18 @@ def _solve_blqmr_batch(args):
         start_col,
     ) = args
 
-    # Import blqmr in worker process
-    from blocksolver import blqmr as worker_blqmr
+    # Import dependencies in worker process
+    try:
+        from blocksolver import blqmr as worker_blqmr
+        from scipy import sparse as worker_sparse
+        import numpy as worker_np
+    except ImportError as e:
+        raise ImportError(f"Worker process missing required imports: {e}")
 
     # Reconstruct sparse matrix in worker process
-    A = sparse.csc_matrix((A_data, A_indices, A_indptr), shape=A_shape, dtype=A_dtype)
+    A = worker_sparse.csc_matrix(
+        (A_data, A_indices, A_indptr), shape=A_shape, dtype=A_dtype
+    )
 
     result = worker_blqmr(
         A,
@@ -146,7 +169,7 @@ def _solve_blqmr_batch(args):
 
 def _solve_iterative_column(args):
     """
-    Worker function for parallel iterative solving (gmres, bicgstab, cg).
+    Worker function for parallel iterative solving (gmres, bicgstab, cg, qmr, minres).
 
     Solves a single RHS column using the specified iterative method.
     """
@@ -164,15 +187,17 @@ def _solve_iterative_column(args):
         use_amg,
     ) = args
 
-    from scipy.sparse.linalg import gmres, bicgstab, cg
+    # Import dependencies in worker process
+    from scipy.sparse.linalg import gmres, bicgstab, cg, qmr, minres
     from scipy import sparse
+    import numpy as np
 
     # Reconstruct sparse matrix in worker process
     A = sparse.csc_matrix((A_data, A_indices, A_indptr), shape=A_shape, dtype=A_dtype)
 
     # Setup preconditioner if AMG requested
     M = None
-    if use_amg and solver_type == "cg":
+    if use_amg and solver_type in ("cg", "minres"):
         try:
             import pyamg
 
@@ -188,6 +213,10 @@ def _solve_iterative_column(args):
         solver_func = bicgstab
     elif solver_type == "cg":
         solver_func = cg
+    elif solver_type == "qmr":
+        solver_func = qmr
+    elif solver_type == "minres":
+        solver_func = minres
     else:
         raise ValueError(f"Unknown solver type: {solver_type}")
 
@@ -252,12 +281,14 @@ def _blqmr_parallel(
             )
         )
 
-    # Solve in parallel
+    # Solve in parallel with proper context
     x = np.zeros((n, ncol), dtype=out_dtype)
     max_flag = 0
 
-    with ProcessPoolExecutor(max_workers=nthread) as executor:
-        results = executor.map(_solve_blqmr_batch, batches)
+    # Get appropriate multiprocessing context
+    ctx = _get_mp_context()
+    with Pool(processes=nthread) as pool:
+        results = pool.map(_solve_blqmr_batch, batches)
 
         for batch_id, start_col, x_batch, batch_flag, niter, relres in results:
             end_col = start_col + x_batch.shape[1]
@@ -269,7 +300,7 @@ def _blqmr_parallel(
 
             if verbose:
                 print(
-                    f"blqmr [{start_col+1}:{end_col}] (worker {batch_id}): "
+                    f"blqmr [{start_col + 1}:{end_col}] (worker {batch_id}): "
                     f"iter={niter}, relres={relres:.2e}, flag={batch_flag}"
                 )
 
@@ -288,7 +319,7 @@ def _iterative_parallel(
     verbose: bool = False,
 ) -> Tuple[np.ndarray, int]:
     """
-    Solve iterative methods (gmres, bicgstab, cg) in parallel.
+    Solve iterative methods (gmres, bicgstab, cg, qmr, minres) in parallel.
 
     Each RHS column is solved independently in a separate process.
     """
@@ -326,12 +357,14 @@ def _iterative_parallel(
                 )
             )
 
-    # Solve in parallel
+    # Solve in parallel with proper context
     x = np.zeros((n, ncol), dtype=out_dtype)
     max_flag = 0
 
-    with ProcessPoolExecutor(max_workers=nthread) as executor:
-        results = executor.map(_solve_iterative_column, tasks)
+    # Get appropriate multiprocessing context
+    ctx = _get_mp_context()
+    with Pool(processes=nthread) as pool:
+        results = pool.map(_solve_iterative_column, tasks)
 
         for col_idx, x_col, info in results:
             x[:, col_idx] = x_col
@@ -339,7 +372,7 @@ def _iterative_parallel(
 
             if verbose:
                 status = "converged" if info == 0 else f"flag={info}"
-                print(f"{solver_type} [col {col_idx+1}]: {status}")
+                print(f"{solver_type} [col {col_idx + 1}]: {status}")
 
     return x, max_flag
 
@@ -376,13 +409,16 @@ def femsolve(
         'cg+amg': CG with AMG preconditioner (SPD, requires pyamg)
         'gmres': GMRES
         'bicgstab': BiCGSTAB
+        'qmr': Quasi-Minimal Residual
+        'minres': MINRES (symmetric/Hermitian only)
+        'minres+amg': MINRES with AMG preconditioner (symmetric, requires pyamg)
     **kwargs : dict
         tol : float - convergence tolerance (default: 1e-10)
         maxiter : int - maximum iterations (default: 1000)
         rhsblock : int - block size for blqmr (default: 8)
         nthread : int - parallel workers for iterative solvers
             (default: min(ncol, cpu_count), set to 1 to disable)
-            Supported by: blqmr, gmres, bicgstab, cg, cg+amg
+            Supported by: blqmr, gmres, bicgstab, cg, cg+amg, qmr, minres, minres+amg
         verbose : bool - print solver progress (default: False)
         spd : bool - True if matrix is symmetric positive definite
         M, M1, M2 : preconditioners (disables parallel for gmres/bicgstab/cg)
@@ -468,6 +504,11 @@ def femsolve(
             # Solve real system (batch solve for all RHS at once)
             x_real = _pardiso_solve(A_real, rhs_real)
 
+            # Handle both 1D and 2D results from pardiso
+            if x_real.ndim == 1:
+                # Single RHS case - reshape to 2D for consistent indexing
+                x_real = x_real.reshape(-1, 1)
+
             # Reconstruct complex solution: x = x_r + j*x_i
             x = x_real[:n, :] + 1j * x_real[n:, :]
         else:
@@ -782,6 +823,121 @@ def femsolve(
                         status = "converged" if info == 0 else f"flag={info}"
                         print(f"bicgstab [col {i+1}]: {status}")
 
+    elif method == "qmr":
+        nthread = kwargs.get("nthread", None)
+        if nthread is None:
+            nthread = min(ncol, multiprocessing.cpu_count())
+        M = kwargs.get("M", None)
+
+        if nthread > 1 and ncol > 1 and M is None:
+            # Parallel solving (without custom preconditioner)
+            x, flag = _iterative_parallel(
+                Amat,
+                rhs,
+                "qmr",
+                tol=tol,
+                maxiter=maxiter,
+                nthread=nthread,
+                use_amg=False,
+                verbose=verbose,
+            )
+        else:
+            # Sequential solving
+            for i in range(ncol):
+                if np.any(rhs[:, i] != 0):
+                    try:
+                        x[:, i], info = qmr(
+                            Amat, rhs[:, i], M1=M, rtol=tol, maxiter=maxiter
+                        )
+                    except TypeError:
+                        x[:, i], info = qmr(
+                            Amat, rhs[:, i], M1=M, tol=tol, maxiter=maxiter
+                        )
+                    flag = max(flag, info)
+                    if verbose:
+                        status = "converged" if info == 0 else f"flag={info}"
+                        print(f"qmr [col {i+1}]: {status}")
+
+    elif method == "minres+amg":
+        if not _HAS_AMG:
+            warnings.warn("pyamg not available, falling back to MINRES")
+            return femsolve(Amat, rhs, method="minres", **kwargs)
+
+        if is_complex:
+            warnings.warn("minres+amg doesn't support complex, falling back to gmres")
+            return femsolve(Amat, rhs, method="gmres", **kwargs)
+
+        nthread = kwargs.get("nthread", None)
+        if nthread is None:
+            nthread = min(ncol, multiprocessing.cpu_count())
+
+        if nthread > 1 and ncol > 1:
+            # Parallel solving
+            x, flag = _iterative_parallel(
+                Amat,
+                rhs,
+                "minres",
+                tol=tol,
+                maxiter=maxiter,
+                nthread=nthread,
+                use_amg=True,
+                verbose=verbose,
+            )
+        else:
+            # Sequential solving
+            ml = _pyamg.smoothed_aggregation_solver(Amat.tocsr())
+            M = ml.aspreconditioner()
+
+            for i in range(ncol):
+                if np.any(rhs[:, i] != 0):
+                    try:
+                        x[:, i], info = minres(
+                            Amat, rhs[:, i], M=M, rtol=tol, maxiter=maxiter
+                        )
+                    except TypeError:
+                        x[:, i], info = minres(
+                            Amat, rhs[:, i], M=M, tol=tol, maxiter=maxiter
+                        )
+                    flag = max(flag, info)
+                    if verbose:
+                        status = "converged" if info == 0 else f"flag={info}"
+                        print(f"minres+amg [col {i+1}]: {status}")
+
+    elif method == "minres":
+        nthread = kwargs.get("nthread", None)
+        if nthread is None:
+            nthread = min(ncol, multiprocessing.cpu_count())
+        M = kwargs.get("M", None)
+
+        if nthread > 1 and ncol > 1 and M is None:
+            # Parallel solving (without custom preconditioner)
+            x, flag = _iterative_parallel(
+                Amat,
+                rhs,
+                "minres",
+                tol=tol,
+                maxiter=maxiter,
+                nthread=nthread,
+                use_amg=False,
+                verbose=verbose,
+            )
+        else:
+            # Sequential solving
+            for i in range(ncol):
+                if np.any(rhs[:, i] != 0):
+                    try:
+                        x[:, i], info = minres(
+                            Amat, rhs[:, i], M=M, rtol=tol, maxiter=maxiter
+                        )
+                    except TypeError:
+                        x[:, i], info = minres(
+                            Amat, rhs[:, i], M=M, tol=tol, maxiter=maxiter
+                        )
+                    flag = max(flag, info)
+                    if verbose:
+                        status = "converged" if info == 0 else f"flag={info}"
+                        print(f"minres [col {i+1}]: {status}")
+
     else:
         raise ValueError(f"Unknown solver: {method}")
 
@@ -792,7 +948,7 @@ def femsolve(
     return x, flag
 
 
-def get_solver_info() -> dict:
+def solverinfo() -> dict:
     """Return information about available solvers."""
     info = {
         "direct_solver": _DIRECT_SOLVER,
@@ -802,7 +958,8 @@ def get_solver_info() -> dict:
         "has_amg": _HAS_AMG,
         "has_blqmr": _HAS_BLQMR,
         "complex_direct": "umfpack" if _HAS_UMFPACK else "superlu",
-        "complex_iterative": ["gmres", "bicgstab"],
+        "complex_iterative": ["gmres", "bicgstab", "qmr"],
+        "symmetric_iterative": ["cg", "minres"],
         "cpu_count": multiprocessing.cpu_count(),
     }
 
@@ -811,4 +968,7 @@ def get_solver_info() -> dict:
         info["blqmr_has_numba"] = HAS_NUMBA
         info["complex_iterative"].insert(0, "blqmr")
 
+    if _HAS_AMG:
+        info["amg_iterative"] = ["cg+amg", "minres+amg"]
+
     return info

{redbirdpy-0.1.0.dist-info → redbirdpy-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redbirdpy
-Version: 0.1.0
+Version: 0.2.0
 Summary: A Python toolbox for Diffuse Optical Tomography (DOT) and Near-Infrared Spectroscopy (NIRS)
 Home-page: https://github.com/fangq/redbirdpy
 Author: Qianqian Fang
@@ -14,7 +14,7 @@ Project-URL: Repository, https://github.com/fangq/redbirdpy
 Project-URL: Bug Tracker, https://github.com/fangq/redbirdpy/issues
 Keywords: Diffuse Optical Tomography,DOT,NIRS,Near-Infrared Spectroscopy,FEM,Finite Element Method,Biomedical Optics,Image Reconstruction,Inverse Problem,Photon Migration,Diffusion Equation,Tissue Optics
 Platform: any
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Healthcare Industry
@@ -37,14 +37,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy>=1.15.0
 Requires-Dist: scipy>=1.0.0
-Provides-Extra: mesh
-Requires-Dist: iso2mesh>=0.5.4; extra == "mesh"
+Requires-Dist: iso2mesh>=0.5.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.0; extra == "dev"
 Requires-Dist: flake8>=3.0; extra == "dev"
 Provides-Extra: all
-Requires-Dist: iso2mesh>=0.5.4; extra == "all"
 Requires-Dist: matplotlib>=3.0; extra == "all"
 Dynamic: author
 Dynamic: home-page
@@ -53,13 +51,13 @@ Dynamic: maintainer
 Dynamic: platform
 Dynamic: requires-python
 
-![Redbird Banner](./doc/images/redbird_banner.png)
+![Redbird Banner](https://raw.githubusercontent.com/fangq/redbird/refs/heads/master/doc/images/redbird_banner.png)
 
 # RedbirdPy - A Model-Based Diffuse Optical Imaging Toolbox for Python
 
-* **Copyright**: (C) Qianqian Fang (2005–2025) \<q.fang at neu.edu>
+* **Copyright**: (C) Qianqian Fang (2005–2026) \<q.fang at neu.edu>
 * **License**: GNU Public License V3 or later
-* **Version**: 0.1.0
+* **Version**: 0.2.0 (Flamingo)
 * **GitHub**: [https://github.com/fangq/redbirdpy](https://github.com/fangq/redbirdpy)
 * **Acknowledgement**: This project is supported by the US National Institute of Health (NIH)
   grant [R01-CA204443](https://reporter.nih.gov/project-details/10982160)
@@ -88,7 +86,7 @@ Dynamic: requires-python
 
 ## Introduction
 
-**Redbird-Python** is a Python translation of the [Redbird MATLAB toolbox](https://github.com/fangq/redbird) for diffuse optical imaging (DOI) and diffuse optical tomography (DOT). It provides a fast, experimentally-validated forward solver for the diffusion equation using the finite-element method (FEM), along with advanced non-linear image reconstruction algorithms.
+**RedbirdPy** is a Python translation of the [Redbird MATLAB toolbox](https://github.com/fangq/redbird) for diffuse optical imaging (DOI) and diffuse optical tomography (DOT). It provides a fast, experimentally-validated forward solver for the diffusion equation using the finite-element method (FEM), along with advanced non-linear image reconstruction algorithms.
 
 Redbird is the result of over two decades of active research in DOT and image reconstruction. It has been the core data analysis tool in numerous publications related to optical breast imaging, prior-guided reconstruction techniques, multi-modal imaging, and wide-field DOT systems.
 
@@ -104,7 +102,7 @@ Redbird is the result of over two decades of active research in DOT and image re
 
 ### Validation
 
-The forward solver is carefully validated against Monte Carlo solvers—**MCX** and **MMC**. The diffusion approximation is valid in high-scattering media where the reduced scattering coefficient (μs') is much greater than the absorption coefficient (μa).
+The forward solver is carefully validated against Monte Carlo solvers - **MCX** and **MMC**. The diffusion approximation is valid in high-scattering media where the reduced scattering coefficient (μs') is much greater than the absorption coefficient (μa).
 
 ---
 
@@ -112,15 +110,15 @@ The forward solver is carefully validated against Monte Carlo solvers—**MCX**
 
 ### Requirements
 
-- Python 3.8+
+- Python 3.6+
 - NumPy
 - SciPy
+- Iso2Mesh
 
 ### Basic Installation
 
 ```bash
 pip install numpy scipy
-# For mesh generation
 pip install iso2mesh  # or from https://github.com/NeuroJSON/pyiso2mesh
 ```
 
@@ -131,7 +129,7 @@ pip install iso2mesh  # or from https://github.com/NeuroJSON/pyiso2mesh
 pip install numba          # JIT compilation
 
 # For accelerated solvers
-pip install blocksolver  # or from https://github.com/fangq/
+pip install blocksolver  # or from https://github.com/fangq/blit
 
 # For other linear solvers
 pip install pypardiso      # Intel MKL PARDISO (fastest direct solver)
@@ -147,7 +145,7 @@ cd redbirdpy
 pip install -e .
 ```
 
-Or simply add the `redbirdpy` folder to your Python path.
+Or simply import `redbirdpy` from inside the repository's top folder.
 
 ---
 
@@ -201,12 +199,12 @@ Redbird performs two main tasks:
 
 Redbird supports four types of image reconstructions:
 
-| Mode | Description |
-|------|-------------|
-| **Bulk Fitting** | Estimate single set of properties for entire domain |
-| **Segmented** | One property set per labeled tissue segment ("hard-prior") |
+| Mode | Description                                                   |
+|------|---------------------------------------------------------------|
+| **Bulk Fitting** | Estimate single set of properties for the entire domain       |
+| **Segmented** | One property set per labeled tissue segment ("hard-prior")    |
 | **Soft-Prior** | Spatial priors as soft constraints (Laplacian, compositional) |
-| **Unconstrained** | Independent properties per node with Tikhonov regularization |
+| **Unconstrained** | Independent properties per node with Tikhonov regularization  |
 
 ---
 
@@ -265,9 +263,9 @@ Redbird supports four types of image reconstructions:
 | Function | Description |
 |----------|-------------|
 | `femsolve(A, b, method)` | Solve linear system with auto-selection |
-| `get_solver_info()` | Query available solver backends |
+| `solverinfo()` | Query available solver backends |
 
-Supported solvers: `pardiso`, `umfpack`, `cholmod`, `superlu`, `blqmr`, `cg`, `cg+amg`, `gmres`, `bicgstab`
+Supported solvers: `pardiso`, `umfpack`, `cholmod`, `superlu`, `blqmr`, `cg`, `cg+amg`, `gmres`, `minres`, `minres+amg`, `qmr`, `bicgstab`
 
 ### `redbirdpy.analytical` - Analytical Solutions
 
@@ -395,8 +393,8 @@ Configure similarly using `dettype`, `detparam1`, `detparam2`, `detpattern`.
 
 ```python
 cfg['prop'] = {
-    '690': np.array([[0, 0, 1, 1], [0.012, 1.1, 0, 1.37]]),
-    '830': np.array([[0, 0, 1, 1], [0.008, 0.9, 0, 1.37]])
+    '690': [[0, 0, 1, 1], [0.012, 1.1, 0, 1.37]],
+    '830': [[0, 0, 1, 1], [0.008, 0.9, 0, 1.37]]
 }
 ```
 
@@ -498,7 +496,7 @@ recon['prop'] = np.tile(cfg['prop'][1,:], (recon['node'].shape[0], 1))
 newrecon, resid = rb.run(cfg, recon, detphi0, lambda_=1e-4)[:2]
 ```
 
-### Wide-Field Reconstruction
+### Wide-Field Forward and Reconstruction
 
 ```python
 # Create illumination patterns
@@ -585,12 +583,12 @@ If you use Redbird in your research, please cite:
 
 ## License
 
-GNU General Public License v3.0 or later - see [LICENSE](LICENSE) file for details.
+GNU General Public License v3.0 or later - see [LICENSE](LICENSE.txt) file for details.
 
 ## Author
 
 **Qianqian Fang** (q.fang@neu.edu)
-Computational Optics & Translational Imaging Lab
+Computational Optics & Translational Imaging (COTI) Lab
 Northeastern University
 
-Python translation based on the [Redbird MATLAB toolbox](https://github.com/fangq/redbirdpy).
+Python translation based on the [Redbird MATLAB toolbox](https://github.com/fangq/redbird).

redbirdpy-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+redbirdpy/__init__.py,sha256=-NzQLn3eHX7KZBmJOUN9IxLitR9GcmBTkEyu8S_k5Yc,3379
+redbirdpy/analytical.py,sha256=9mMTU8EwDbRn5JqPsFgSdh0LL4WXc4BaXQpsECl_Wg4,26681
+redbirdpy/forward.py,sha256=Gtu7v41h_AVMQ5sfyMSDkOIzzYTP2vn0SoxUQDR_lS8,18785
+redbirdpy/property.py,sha256=fb8tOc7TLS7h6GQ61GjAbEwawJb5kLFULFm6-4U3MT0,18804
+redbirdpy/recon.py,sha256=tnsVIYc6dMB5p9iWXLdOtdMnAe_YLHruci9g-WmvvS8,30290
+redbirdpy/solver.py,sha256=0lF41cOv0rv3W1JvAYhkgVWiO3hP2QWdltmZl5UH_Y8,32100
+redbirdpy/utility.py,sha256=F8JYSUex0zWPds-f1lerdcPRT3bvGEPVw2CinDvFzu0,35360
+redbirdpy-0.2.0.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+redbirdpy-0.2.0.dist-info/METADATA,sha256=GpCSlcR76xneykT8NM802lgjREa27_Cp4KeNH9kSYio,19640
+redbirdpy-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+redbirdpy-0.2.0.dist-info/top_level.txt,sha256=BbzExHReBzfre6x0TePxSeA7BZK4skcjnnTkHOTDoyA,10
+redbirdpy-0.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+redbirdpy-0.2.0.dist-info/RECORD,,

redbirdpy-0.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-redbirdpy/__init__.py,sha256=I0dQ6LYcRWSL0Z525n52VE2BLEDQeTOQqM_EUwilgxk,3379
-redbirdpy/analytical.py,sha256=9mMTU8EwDbRn5JqPsFgSdh0LL4WXc4BaXQpsECl_Wg4,26681
-redbirdpy/forward.py,sha256=Gtu7v41h_AVMQ5sfyMSDkOIzzYTP2vn0SoxUQDR_lS8,18785
-redbirdpy/property.py,sha256=fb8tOc7TLS7h6GQ61GjAbEwawJb5kLFULFm6-4U3MT0,18804
-redbirdpy/recon.py,sha256=tnsVIYc6dMB5p9iWXLdOtdMnAe_YLHruci9g-WmvvS8,30290
-redbirdpy/solver.py,sha256=mhhbyxxZATm8v_lVRCsYnwug4fsVyOU2ym665jmFO2E,26049
-redbirdpy/utility.py,sha256=F8JYSUex0zWPds-f1lerdcPRT3bvGEPVw2CinDvFzu0,35360
-redbirdpy-0.1.0.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-redbirdpy-0.1.0.dist-info/METADATA,sha256=1FeYa9cvr6KwvOK-_nr9yfblMydktDCLQuv1mQDvAW8,19510
-redbirdpy-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-redbirdpy-0.1.0.dist-info/top_level.txt,sha256=BbzExHReBzfre6x0TePxSeA7BZK4skcjnnTkHOTDoyA,10
-redbirdpy-0.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-redbirdpy-0.1.0.dist-info/RECORD,,