Bump NumPy Version

Author: Sampreet

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v1.1.0 - 2025/03/11 - 00 - Bump NumPy Version
+* Updated all modules to support for NumPy 2.x.x.
+* Added deprecation warning to `qom.solvers.stochastic.MCQTSolver` class.
+* Updated `requirements` and `setup`.
+* Updated documentation and `README`.
+
 ## v1.0.2 - 2024/06/23 - 00 - GUI Hotfix
 * String support in axis values in `qom.loopers.base.BaseLooper` class.
 * Updated `qom.solvers` package:

README.md

@@ -1,9 +1,9 @@
 # The Quantum Optomechanics Toolbox
 
-![Latest Version](https://img.shields.io/badge/version-1.0.2-red?style=for-the-badge)
+![Latest Version](https://img.shields.io/badge/version-1.1.0-red?style=for-the-badge)
 [![Last Commit](https://img.shields.io/github/last-commit/sampreet/qom?style=for-the-badge)](https://github.com/sampreet/qom/blob/master/CHANGELOG.md)
 
-[![Last Release](https://img.shields.io/github/release-date/sampreet/qom?style=flat-square&label=Last%20Release)](https://github.com/sampreet/qom/releases/tag/v1.0.1)
+[![Last Release](https://img.shields.io/github/release-date/sampreet/qom?style=flat-square&label=Last%20Release)](https://github.com/sampreet/qom/releases/tag/v1.1.0)
 [![Open Issues](https://img.shields.io/github/issues-raw/sampreet/qom?style=flat-square)](https://github.com/sampreet/qom/issues?q=is%3Aopen+is%3Aissue)
 [![Closed Issues](https://img.shields.io/github/issues-closed-raw/sampreet/qom?style=flat-square)](https://github.com/sampreet/qom/issues?q=is%3Aissue+is%3Aclosed)
 
@@ -12,18 +12,22 @@
 The Quantum Optomechanics Toolbox (packaged as `qom`) is a wrapper-styled, scalable toolbox featuring multiple modules for the calculation of stationary as well as dynamical properties of many-body quantum optomechanical systems.
 Backed by numerical libraries like NumPy and SciPy, and featuring the highly customizable visualizations offered by Matplotlib and Seaborn APIs, the toolbox aims to serve as an easy-to-use alternative to writing code explicitly and avoiding repetitive exercises for presentable visuals.
 
+> **Note**  
+> The toolbox is not under active maintenance since 2023 and addition of newer features are not planned for the near future.
+> However, the current CPU-based modules fully support the simulation of linearized quantum optomechanical systems and their related analysis.
+> For the simulation of more general systems, ``QuTiP`` (``> v5.0``) provides a much faster interface.
+
 ### Key Features!
 
 * Run automatically-managed loops in parallel and pool results.
 * Solve for stability and classical/quantum signatures seamlessly.
 * Configure plots across plotting libraries with a common syntax.
 
-### What's New in v1.0!
+### What's New in v1.x!
 
 * Non-linear Schrodinger equation solver with integration support.
 * Attractor detection and bifurcation for non-linear dynamical systems.
 * Huge performance boost with NumPy-based vectorization.
-* Faster Monte-Carlo quantum trajectories solver for low-dimensional Hilbert spaces (deprecated since `qom-v1.0.2`).
 
 | Dynamical Stability | Quantum Correlations | 
 |---|---|
@@ -58,6 +62,7 @@ Backed by numerical libraries like NumPy and SciPy, and featuring the highly cus
 | Wigner distribution depicting the evolution of mechanical squeezing in a modulated optomechanical system. | Soliton propagation in an array of optomechanical systems at different phase lags between the input solitons. |
 
 A set of notebooks and scripts to demonstrate the usage of the toolbox can be found in the [examples repository](https://github.com/sampreet/qom-examples).
+Research papers solved using the toolbox can be found in the [papers repository](https://github.com/sampreet/qom-papers).
 
 ## Installation
 
@@ -71,20 +76,20 @@ conda create -n qom python
 conda activate qom
 ```
 
-The toolbox primarily relies on `numpy` (for fast numerical algebra), `scipy` (for numerical methods), `sympy` (for symbolic algebra), `seaborn` (for color palettes) and `matplotlib` (for plotting results).
+The toolbox primarily relies on `numpy` (for fast numerical algebra), `scipy` (for numerical methods), `sympy` (for symbolic algebra), `matplotlib` (for plotting results) and `seaborn` (for color palettes).
 These libraries can be installed using:
 
 ```bash
-conda install matplotlib numpy scipy sympy seaborn
+conda install numpy scipy sympy matplotlib seaborn "pyqt<6.0.0"
 ```
 
-***Note: To run the GUI modules, `pyqt` should be installed separately.***
+***Note: PyQt5 is only required to run the GUI modules and can skipped.***
 
-Once the dependencies are installed, the toolbox can be installed via PyPI or locally.
+Once the dependencies are installed, the toolbox can be installed via GitHub or locally.
 
 The documentation of the latest release is available [here](https://sampreet.github.io/qom-docs).
 
-### Installing via PyPI
+### Installing via GitHub
 
 To install the last release via the Python Package Index, execute: 
 

docs/source/index.rst

@@ -1,7 +1,7 @@
 .. Quantum Optomechanics Toolbox documentation master file, created by
    sphinx-quickstart on Fri Dec 4 15:06:12 2020.
 
-Welcome to the ``qom-v1.0.2`` Documentation!
+Welcome to the ``qom-v1.1.0`` Documentation!
 ============================================
 
 The Quantum Optomechanics Toolbox (packaged as ``qom``) is a wrapper-styled, scalable toolbox featuring multiple modules for the calculation of stationary as well as dynamical properties of linearized quantum optomechanical systems.
@@ -19,13 +19,12 @@ Key Features
 * Solve for stability and classical/quantum signatures seamlessly.
 * Configure plots across plotting libraries with a common syntax.
 
-What's New in v1.0!
+What's New in v1.x!
 -------------------
 
 * Non-linear Schrodinger equation solver with integration support.
 * Attractor detection and bifurcation for non-linear dynamical systems.
 * Huge performance boost with NumPy-based vectorization.
-* Faster Monte-Carlo quantum trajectories solver for low-dimensional Hilbert spaces (deprecated since ``qom-v1.0.2``).
 
 .. list-table::
    :widths: 50 50
@@ -97,6 +96,7 @@ Examples
      - Soliton propagation in an array of optomechanical systems at different phase lags between the input solitons.
 
 A set of notebooks and scripts to demonstrate the usage of the toolbox can be found in the `examples repository <https://github.com/sampreet/qom-examples>`_.
+Research papers solved using the toolbox can be found in the `papers repository<https://github.com/sampreet/qom-papers>`_.
 
 Installation
 ============
@@ -112,21 +112,21 @@ Once ``Anaconda`` is set up, create and activate a new ``conda`` environment usi
    conda create -n qom python
    conda activate qom
 
-The toolbox primarily relies on ``numpy`` (for fast numerical algebra), ``scipy`` (for numerical methods), ``sympy`` (for symbolic algebra), ``seaborn`` (for color palettes) and ``matplotlib`` (for plotting results).
+The toolbox primarily relies on ``numpy`` (for fast numerical algebra), ``scipy`` (for numerical methods), ``sympy`` (for symbolic algebra), ``matplotlib`` (for plotting results) and ``seaborn`` (for color palettes).
 These libraries can be installed using:
 
 .. code-block:: bash
 
-   conda install matplotlib numpy scipy sympy seaborn
+   conda install matplotlib numpy scipy sympy seaborn "pyqt<6.0.0"
 
-.. note:: To run the GUI modules, ``pyqt`` should be installed separately.
+.. note:: PyQt5 is only required to run the GUI modules and can skipped..
 
-Once the dependencies are installed, the toolbox can be installed via PyPI or locally.
+Once the dependencies are installed, the toolbox can be installed via GitHub or locally.
 
 The documentation of the latest release is available `here <https://sampreet.github.io/qom-docs>`_.
 
-Installing via PyPI
--------------------
+Installing via GitHub
+---------------------
 
 To install the packages via the Python Package Index (PyPI), execute: 
 

qom/loopers/base.py

@@ -6,7 +6,7 @@
 __name__ = 'qom.loopers.base'
 __authors__ = ["Sampreet Kalita"]
 __created__ = "2020-12-21"
-__updated__ = "2023-10-28"
+__updated__ = "2025-03-11"
 
 # dependencies
 from decimal import Decimal
@@ -168,7 +168,7 @@ def set_axis(self, axis:str):
             if type(_val[0]) is int:
                 _val = np.array(_val, dtype=np.int32)
             elif type(_val[0]) is float:
-                _val = np.array(_val, dtype=np.float_)
+                _val = np.array(_val, dtype=np.float64)
             else:
                 _val = np.array(_val)
         # update values
@@ -181,14 +181,14 @@ def set_axis(self, axis:str):
             assert 'min' in _axis and 'max' in _axis, "Key ``'{}'`` should contain keys ``'min'`` and ``'max'`` to define axis range".format(axis)
 
             # extract dimension
-            _min = np.float_(_axis['min'])
-            _max = np.float_(_axis['max'])
+            _min = np.float64(_axis['min'])
+            _max = np.float64(_axis['max'])
             _dim = int(_axis.get('dim', 101))
             _scale = str(_axis.get('scale', 'linear'))
 
             # handle single value
             if _dim == 1:
-                _val = np.array([_min], dtype=np.float_)
+                _val = np.array([_min], dtype=np.float64)
 
             # set values
             else:
@@ -326,15 +326,15 @@ def get_X_results(self):
             for i in range(len(vals)):
                 count = len(vals[i]) if len(vals[i]) > count else count
                 dtype = type(vals[i][0]) if len(vals[i]) > 0 and dtype is None else dtype
-            vs = np.empty((len(vals), count), dtype=np.float_ if dtype is None else dtype)
+            vs = np.empty((len(vals), count), dtype=np.float64 if dtype is None else dtype)
             # update info
             self.updater.update_info(
                 status="-" * (12 - len(self.name) - len(str(count))) + "Reshaping with NaN values (BaseLooper): New Length = {}".format(count)
             )
             # update extra entries to NaN
             for i in range(len(vals)):
                 vs[i, :len(vals[i])] = vals[i]
-                vs[i, len(vals[i]):] = np.NaN
+                vs[i, len(vals[i]):] = np.nan
             # convert to lists
             vs = vs.tolist()
 

qom/misc.py

@@ -4,9 +4,9 @@
 """Module containing different operators."""
 
 __name__    = 'qom.misc'
-__authors__ = ['Sampreet Kalita']
-__created__ = '2023-08-13'
-__updated__ = '2024-06-21'
+__authors__ = ["Sampreet Kalita"]
+__created__ = "2023-08-13"
+__updated__ = "2025-03-11"
 
 # dependencies
 from copy import deepcopy
@@ -28,11 +28,11 @@ def op_annihilation(N):
     """
 
     # data
-    data = np.sqrt(np.arange(1, N, dtype=np.complex_))
+    data = np.sqrt(np.arange(1, N, dtype=np.complex128))
     # column indices
-    indices = np.arange(1, N, dtype=np.int_)
+    indices = np.arange(1, N, dtype=np.int32)
     # pointers to column indices
-    indptr = np.arange(N + 1, dtype=np.int_)
+    indptr = np.arange(N + 1, dtype=np.int32)
     indptr[-1] = N - 1
     # return annihilation operator
     return sp.csr_matrix((data, indices, indptr), shape=(N, N)).toarray()
@@ -69,11 +69,11 @@ def op_identity(N):
     """
 
     # data
-    data = np.ones(N, dtype=np.complex_)
+    data = np.ones(N, dtype=np.complex128)
     # column indices
-    indices = np.arange(0, N, dtype=np.int_)
+    indices = np.arange(0, N, dtype=np.int32)
     # pointers to column indices
-    indptr = np.arange(N + 1, dtype=np.int_)
+    indptr = np.arange(N + 1, dtype=np.int32)
     indptr[-1] = N
     # return identity operator
     return sp.csr_matrix((data, indices, indptr), shape=(N, N)).toarray()
@@ -92,7 +92,7 @@ def op_sigma_x():
         Pauli-X operator.
     """
 
-    return np.array([[0, 1], [1, 0]], dtype=np.complex_)
+    return np.array([[0, 1], [1, 0]], dtype=np.complex128)
 
 def op_sigma_y():
     """Function to obtain the Pauli-Y operator.
@@ -108,7 +108,7 @@ def op_sigma_y():
         Pauli-Y operator.
     """
 
-    return np.array([[0, -1j], [1j, 0]], dtype=np.complex_)
+    return np.array([[0, -1j], [1j, 0]], dtype=np.complex128)
 
 def op_sigma_z():
     """Function to obtain the Pauli-Z operator.
@@ -124,7 +124,7 @@ def op_sigma_z():
         Pauli-Z operator.
     """
 
-    return np.array([[1, 0], [0, -1]], dtype=np.complex_)
+    return np.array([[1, 0], [0, -1]], dtype=np.complex128)
 
 def dagger(A):
     """Function to obtain the Hermitian conjugate of an operator.
@@ -187,11 +187,11 @@ def state_fock(N, n):
     assert N > n, "Hilbert space dimension insufficient"
 
     # data
-    data = np.array([1], dtype=np.complex_)
+    data = np.array([1], dtype=np.complex128)
     # row indices
-    indices = np.array([n], dtype=np.int_)
+    indices = np.array([n], dtype=np.int32)
     # pointers to row indices
-    indptr = np.array([0, 1], dtype=np.int_)
+    indptr = np.array([0, 1], dtype=np.int32)
     # return fock state
     return sp.csc_matrix((data, indices, indptr), shape=(N, 1)).toarray()
 

qom/solvers/base.py

@@ -6,7 +6,7 @@
 __name__ = 'qom.solvers.base'
 __authors__ = ["Sampreet Kalita"]
 __created__ = "2023-07-04"
-__updated__ = "2023-08-13"
+__updated__ = "2025-03-08"
 
 # dependencies
 from decimal import Decimal
@@ -35,8 +35,8 @@ def get_all_times(params):
     """
 
     # extract frequently used variables
-    t_min = np.float_(params['t_min'])
-    t_max = np.float_(params['t_max'])
+    t_min = np.float64(params['t_min'])
+    t_max = np.float64(params['t_max'])
     t_dim = int(params['t_dim'])
 
     # calculate times
@@ -80,8 +80,8 @@ def validate_Modes_Corrs(Modes=None, Corrs=None, is_modes_required:bool=False, i
     assert Corrs is not None if is_corrs_required else True, "Missing required parameter ``Corrs``"
 
     # handle list
-    Modes  = np.array(Modes, dtype=np.complex_) if Modes is not None and type(Modes) is list else Modes
-    Corrs  = np.array(Corrs, dtype=np.float_) if Corrs is not None and type(Corrs) is list else Corrs
+    Modes  = np.array(Modes, dtype=np.complex128) if Modes is not None and type(Modes) is list else Modes
+    Corrs  = np.array(Corrs, dtype=np.float64) if Corrs is not None and type(Corrs) is list else Corrs
 
     # validate shapes
     assert len(Modes.shape) == 2 if Modes is not None else True, "``Modes`` should be of shape ``(dim, num_modes)``"
@@ -116,15 +116,15 @@ def validate_As_Coeffs(As=None, Coeffs=None):
         # validate drift matrix
         assert isinstance(As, Union[list, np.ndarray].__args__), "``As`` should be of type ``list`` or ``numpy.ndarray``"
         # convert to numpy array
-        As = np.array(As, dtype=np.float_) if type(As) is list else As
+        As = np.array(As, dtype=np.float64) if type(As) is list else As
         # validate shape
         assert len(As.shape) == 3 and As.shape[1] == As.shape[2], "``As`` should be of shape ``(dim_0, 2 * num_modes, 2 * num_modes)``"
     # if coefficients are given
     else:
         # validate coefficients
         assert isinstance(Coeffs, Union[list, np.ndarray].__args__), "``Coeffs`` should be of type ``list`` or ``numpy.ndarray``"
         # convert to numpy array
-        Coeffs = np.array(Coeffs, dtype=np.float_) if type(Coeffs) is list else Coeffs
+        Coeffs = np.array(Coeffs, dtype=np.float64) if type(Coeffs) is list else Coeffs
         # validate shape
         assert len(Coeffs.shape) == 2, "``Coeffs`` should be of shape ``(dim_0, 2 * num_modes + 1)``"