mini-pole 0.3__tar.gz

mini_pole-0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lzphy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mini_pole-0.3/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.2
+Name: mini_pole
+Version: 0.3
+Summary: The Python code provided implements the matrix-valued version of the Minimal Pole Method (MPM) as described in Phys. Rev. B 110, 235131 (2024).
+Home-page: https://github.com/Green-Phys/MiniPole
+Author: Lei Zhang
+Author-email: lzphy@umich.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Minimal Pole Method (MPM)
+The Python code provided implements the matrix-valued version of the Minimal Pole Method (MPM) as described in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131), extending the scalar-valued method introduced in [Phys. Rev. B 110, 035154 (2024)](https://doi.org/10.1103/PhysRevB.110.035154).
+
+The input of the simulation is the Matsubara data $G(i \omega_n)$ sampled on a uniform grid $\lbrace i\omega_{0}, i\omega_{1}, \cdots, i\omega_{n_{\omega}-1} \rbrace$, where  $\omega_n=\frac{(2n+1)\pi}{\beta}$ for fermions and $\frac{2n\pi}{\beta}$ for bosons, and $n_{\omega}$ is the total number of sampling points.
+
+## 1. Installation
+
+### Dependencies
+- `numpy`
+- `scipy`
+- `matplotlib`
+
+### Installation Commands
+1. Via `setup.py`:
+   ```bash
+   python3 setup.py install
+
+2. Or via `pip`:
+   ```bash
+   pip install mini_pole
+
+## 2. Usage
+### i) The standard MPM is performed using the following command:
+
+**p = MiniPole(G_w, w, n0 = "auto", n0_shift = 0, err = None, err_type = "abs", M = None, symmetry = False, G_symmetric = False, compute_const = False, plane = None, include_n0 = True, k_max = 999, ratio_max = 10)**
+        
+    Parameters
+    ----------
+    1. G_w : ndarray
+        An (n_w, n_orb, n_orb) or (n_w,) array containing the Matsubara data.
+    2. w : ndarray
+        An (n_w,) array containing the corresponding real-valued Matsubara grid.
+    3. n0 : int or str, default="auto"
+        If "auto", n0 is automatically selected with an additional shift specified by n0_shift.
+        If a non-negative integer is provided, n0 is fixed at that value.
+    4. n0_shift : int, default=0
+        The shift applied to the automatically determined n0.
+    5. err : float
+        Error tolerance for calculations.
+    6. err_type : str, default="abs"
+        Specifies the type of error: "abs" for absolute error or "rel" for relative error.
+    7. M : int, optional
+        The number of poles in the final result. If not specified, the precision from the first ESPRIT is used to extract poles in the second ESPRIT.
+    8. symmetry : bool, default=False
+        Determines whether to preserve up-down symmetry.
+    9. G_symmetric : bool, default=False
+        If True, the Matsubara data will be symmetrized such that G_{ij}(z) = G_{ji}(z).
+    10. compute_const : bool, default=False
+        Determines whether to compute the constant term in G(z) = sum_l Al / (z - xl) + const.
+        If False, the constant term is fixed at 0.
+    11. plane : str, optional
+        Specifies whether to use the original z-plane or the mapped w-plane to compute pole weights.
+    12. include_n0 : bool, default=False
+        Determines whether to include the first n0 input points when weights are calculated in the z-plane.
+    13. k_max : int, default=999
+        The maximum number of contour integrals.
+    14. ratio_max : float, default=10
+        The maximum ratio of oscillation when automatically choosing n0.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+### ii) The MPM-DLR algorithm is performed using the following command:
+
+**p = MiniPoleDLR(Al_dlr, xl_dlr, beta, n0, nmax = None, err = None, err_type = "abs", M = None, symmetry = False, k_max=200, Lfactor = 0.4)**
+
+    Parameters
+    ----------
+    1. Al_dlr (numpy.ndarray): DLR coefficients, either of shape (r,) or (r, n_orb, n_orb).
+    2. xl_dlr (numpy.ndarray): DLR grid for the real frequency, an array of shape (r,).
+    3. beta (float): Inverse temperature of the system (1/kT).
+    4. n0 (int): Number of initial points to discard, typically in the range (0, 10).
+    5. nmax (int): Cutoff for the Matsubara frequency when symmetry is False.
+    6. err (float): Error tolerance for calculations.
+    7. err_type (str): Specifies the type of error, "abs" for absolute error or "rel" for relative error.
+    8. M (int): Specifies the number of poles to be recovered.
+    9. symmetry (bool): Whether to impose up-down symmetry (True or False).
+    10. k_max (int): Number of moments to be calculated.
+    11. Lfactor (float): Ratio of L/N in the ESPRIT algorithm.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+## 3. Examples
+
+The scripts in the *examples* folder demonstrate the usage of MPM and MPM-DLR.
+
+### i) MPM Algorithm
+
+The *examples/MPM* folder includes a Jupyter notebook that demonstrates how to use `MiniPole` to recover synthetic spectral functions. You can modify the lambda expression in the `GreenFunc` class to recover a different spectrum, but please remember to update the lower and upper bounds (x_min and x_max) of the spectrum accordingly. Additional details will be provided in the future.
+
+### ii) MPM-DLR Algorithm
+
+The *examples/MPM_DLR* folder contains scripts to recover the band structure of Si, as shown in the middle panel of Fig. 9 in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131).
+
+#### Steps:
+
+a) Download the input data file [Si_dlr.h5](https://drive.google.com/file/d/1_bNvbgOHewiujHYEcf-CCpGxlZP9cRw_/view?usp=drive_link) to the *examples/MPM_DLR/* directory.
+
+b) Obtain the recovered poles by running **python3 cal_band_dlr.py --obs=`<option>`**, where **`<option>`** can be "S" (self-energy), "Gii" (scalar-valued Green's function), or "G" (matrix-valued Green's function).
+
+c) Plot the band structure by running **python3 plt_band_dlr.py --obs=`<option>`**.
+
+#### Note:
+
+a) Reference runtime on a single core of a laptop (using the M1 Max Apple chip as an example): 13 seconds for "Gii" and 160 seconds for both "G" and "S".
+
+b) Parallel computation is supported in **cal_band_dlr.py** to speed up the process on multiple cores. Use the following command: **mpirun -n `<num_cores>` python3 cal_band_dlr.py --obs=`<option>`**, where **`<num_cores>`** is the number of cores and **`<option>`** is "S," "Gii," or "G".
+
+c) Full Parameters for **cal_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--n0` (int): Parameter $n_0$ as described in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131).
+   - `--err` (float): Error tolerance for computations. Default is `1.e-10`.
+   - `--symmetry` (bool): Specifies whether to preserve up-down symmetry in calculations.
+
+d) Full Parameters for **plt_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--w_min` (float): Lower bound of the real frequency in eV. Default is `-12`.
+   - `--w_max` (float): Upper bound of the real frequency in eV. Default is `12`.
+   - `--n_w` (int): Number of frequencies between `w_min` and `w_max`. Default is `200`.
+   - `--eta` (float): Broadening parameter. Default is `0.005`.

mini_pole-0.3/README.md

@@ -0,0 +1,129 @@
+# Minimal Pole Method (MPM)
+The Python code provided implements the matrix-valued version of the Minimal Pole Method (MPM) as described in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131), extending the scalar-valued method introduced in [Phys. Rev. B 110, 035154 (2024)](https://doi.org/10.1103/PhysRevB.110.035154).
+
+The input of the simulation is the Matsubara data $G(i \omega_n)$ sampled on a uniform grid $\lbrace i\omega_{0}, i\omega_{1}, \cdots, i\omega_{n_{\omega}-1} \rbrace$, where  $\omega_n=\frac{(2n+1)\pi}{\beta}$ for fermions and $\frac{2n\pi}{\beta}$ for bosons, and $n_{\omega}$ is the total number of sampling points.
+
+## 1. Installation
+
+### Dependencies
+- `numpy`
+- `scipy`
+- `matplotlib`
+
+### Installation Commands
+1. Via `setup.py`:
+   ```bash
+   python3 setup.py install
+
+2. Or via `pip`:
+   ```bash
+   pip install mini_pole
+
+## 2. Usage
+### i) The standard MPM is performed using the following command:
+
+**p = MiniPole(G_w, w, n0 = "auto", n0_shift = 0, err = None, err_type = "abs", M = None, symmetry = False, G_symmetric = False, compute_const = False, plane = None, include_n0 = True, k_max = 999, ratio_max = 10)**
+        
+    Parameters
+    ----------
+    1. G_w : ndarray
+        An (n_w, n_orb, n_orb) or (n_w,) array containing the Matsubara data.
+    2. w : ndarray
+        An (n_w,) array containing the corresponding real-valued Matsubara grid.
+    3. n0 : int or str, default="auto"
+        If "auto", n0 is automatically selected with an additional shift specified by n0_shift.
+        If a non-negative integer is provided, n0 is fixed at that value.
+    4. n0_shift : int, default=0
+        The shift applied to the automatically determined n0.
+    5. err : float
+        Error tolerance for calculations.
+    6. err_type : str, default="abs"
+        Specifies the type of error: "abs" for absolute error or "rel" for relative error.
+    7. M : int, optional
+        The number of poles in the final result. If not specified, the precision from the first ESPRIT is used to extract poles in the second ESPRIT.
+    8. symmetry : bool, default=False
+        Determines whether to preserve up-down symmetry.
+    9. G_symmetric : bool, default=False
+        If True, the Matsubara data will be symmetrized such that G_{ij}(z) = G_{ji}(z).
+    10. compute_const : bool, default=False
+        Determines whether to compute the constant term in G(z) = sum_l Al / (z - xl) + const.
+        If False, the constant term is fixed at 0.
+    11. plane : str, optional
+        Specifies whether to use the original z-plane or the mapped w-plane to compute pole weights.
+    12. include_n0 : bool, default=False
+        Determines whether to include the first n0 input points when weights are calculated in the z-plane.
+    13. k_max : int, default=999
+        The maximum number of contour integrals.
+    14. ratio_max : float, default=10
+        The maximum ratio of oscillation when automatically choosing n0.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+### ii) The MPM-DLR algorithm is performed using the following command:
+
+**p = MiniPoleDLR(Al_dlr, xl_dlr, beta, n0, nmax = None, err = None, err_type = "abs", M = None, symmetry = False, k_max=200, Lfactor = 0.4)**
+
+    Parameters
+    ----------
+    1. Al_dlr (numpy.ndarray): DLR coefficients, either of shape (r,) or (r, n_orb, n_orb).
+    2. xl_dlr (numpy.ndarray): DLR grid for the real frequency, an array of shape (r,).
+    3. beta (float): Inverse temperature of the system (1/kT).
+    4. n0 (int): Number of initial points to discard, typically in the range (0, 10).
+    5. nmax (int): Cutoff for the Matsubara frequency when symmetry is False.
+    6. err (float): Error tolerance for calculations.
+    7. err_type (str): Specifies the type of error, "abs" for absolute error or "rel" for relative error.
+    8. M (int): Specifies the number of poles to be recovered.
+    9. symmetry (bool): Whether to impose up-down symmetry (True or False).
+    10. k_max (int): Number of moments to be calculated.
+    11. Lfactor (float): Ratio of L/N in the ESPRIT algorithm.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+## 3. Examples
+
+The scripts in the *examples* folder demonstrate the usage of MPM and MPM-DLR.
+
+### i) MPM Algorithm
+
+The *examples/MPM* folder includes a Jupyter notebook that demonstrates how to use `MiniPole` to recover synthetic spectral functions. You can modify the lambda expression in the `GreenFunc` class to recover a different spectrum, but please remember to update the lower and upper bounds (x_min and x_max) of the spectrum accordingly. Additional details will be provided in the future.
+
+### ii) MPM-DLR Algorithm
+
+The *examples/MPM_DLR* folder contains scripts to recover the band structure of Si, as shown in the middle panel of Fig. 9 in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131).
+
+#### Steps:
+
+a) Download the input data file [Si_dlr.h5](https://drive.google.com/file/d/1_bNvbgOHewiujHYEcf-CCpGxlZP9cRw_/view?usp=drive_link) to the *examples/MPM_DLR/* directory.
+
+b) Obtain the recovered poles by running **python3 cal_band_dlr.py --obs=`<option>`**, where **`<option>`** can be "S" (self-energy), "Gii" (scalar-valued Green's function), or "G" (matrix-valued Green's function).
+
+c) Plot the band structure by running **python3 plt_band_dlr.py --obs=`<option>`**.
+
+#### Note:
+
+a) Reference runtime on a single core of a laptop (using the M1 Max Apple chip as an example): 13 seconds for "Gii" and 160 seconds for both "G" and "S".
+
+b) Parallel computation is supported in **cal_band_dlr.py** to speed up the process on multiple cores. Use the following command: **mpirun -n `<num_cores>` python3 cal_band_dlr.py --obs=`<option>`**, where **`<num_cores>`** is the number of cores and **`<option>`** is "S," "Gii," or "G".
+
+c) Full Parameters for **cal_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--n0` (int): Parameter $n_0$ as described in [Phys. Rev. B 110, 235131 (2024)](https://doi.org/10.1103/PhysRevB.110.235131).
+   - `--err` (float): Error tolerance for computations. Default is `1.e-10`.
+   - `--symmetry` (bool): Specifies whether to preserve up-down symmetry in calculations.
+
+d) Full Parameters for **plt_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--w_min` (float): Lower bound of the real frequency in eV. Default is `-12`.
+   - `--w_max` (float): Upper bound of the real frequency in eV. Default is `12`.
+   - `--n_w` (int): Number of frequencies between `w_min` and `w_max`. Default is `200`.
+   - `--eta` (float): Broadening parameter. Default is `0.005`.

mini_pole-0.3/mini_pole/__init__.py

@@ -0,0 +1,5 @@
+from .con_map import *
+from .esprit import *
+from .green_func import *
+from .mini_pole_dlr import *
+from .mini_pole import *

mini_pole-0.3/mini_pole/con_map.py

@@ -0,0 +1,167 @@
+import numpy as np
+
+class ConMapGeneric:
+    '''
+    Generic holomorphic mapping which works for any cases.
+    '''
+    def __init__(self, w_m, dw_h, branch_in = True):
+        '''
+        Initialize the class with w_m and dw_h, which correspond to $\omega_{\rm m}$ and $\Delta \omega_{\rm h}$ in the paper, respectively.
+        Points in the z plane are mapped to the inside (outside) of the unit disk in the w plane when branch_in is True (False).
+        '''
+        assert dw_h.real > 0.0 and dw_h.imag == 0.0
+        self.w_m = w_m
+        self.dw_h = dw_h
+        self.branch_in = branch_in
+        self.w_inf = [0.0]
+    
+    def cal_z(self, w):
+        '''
+        Intermediate function of z(w) which only works for a single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (w - 1.0 / w) + 1j * self.w_m
+    
+    def cal_w(self, z):
+        '''
+        Intermediate function of w(z) which only works for a single point.
+        '''
+        x = (z - 1j * self.w_m) / self.dw_h
+        w = x - np.sqrt(x ** 2.0 + 1.0)
+        if self.branch_in:
+            if np.absolute(w) > 1.0:
+                w = 2.0 * x - w
+        else:
+            if np.absolute(w) < 1.0:
+                w = 2.0 * x - w
+        return w
+    
+    def cal_dz(self, w):
+        '''
+        Intermediate function of dz(w) which only works for single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (1.0 + 1.0 / w ** 2.0)
+    
+    def z(self, w):
+        '''
+        Calculate z from w.
+        '''
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        '''
+        Calculate w from z.
+        '''
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        '''
+        Calculate dz/dw at value w.
+        '''
+        return np.vectorize(self.cal_dz)(w)
+
+class ConMapGapless:
+    '''
+    conformal mapping which works for both gapless and gapped cases
+    '''
+    def __init__(self, w_min):
+        assert w_min > 0.0
+        self.w_min = w_min
+        self.w_inf = [-1.0, 1.0]
+    
+    def cal_z(self, w):
+        assert np.abs(w) < 1.0 + 1.e-15
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 2.0 * self.w_min * w / (1.0 - w * w)
+    
+    def cal_w(self, z):
+        if z == 0.0:
+            w = 0.0
+        else:
+            w = self.w_min * (np.sqrt(1.0 / (z * z) + 1.0 / (self.w_min * self.w_min)) - 1.0 / z)
+            if np.absolute(w) > 1.0:
+                w = -w - 2.0 * self.w_min / z
+        return w
+    
+    def cal_dz(self, w):
+        assert np.abs(w) < 1.0 + 1.e-15
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 2.0 * self.w_min * (1.0 + w ** 2) / (1.0 - w ** 2) ** 2
+    
+    def z(self, w):
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        return np.vectorize(self.cal_dz)(w)
+
+class ConMapRet:
+    '''
+    Holomorphic mapping for the retarded Green's function.
+    '''
+    def __init__(self, w_m, dw_h):
+        '''
+        Initialize the class with w_m and dw_h.
+        Points in the z plane are mapped to the inside of the unit disk in the w plane.
+        '''
+        assert dw_h.real > 0.0 and dw_h.imag == 0.0
+        self.w_m = w_m
+        self.dw_h = dw_h
+        self.w_inf = [0.0]
+    
+    def cal_z(self, w):
+        '''
+        Intermediate function of z(w) which only works for a single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (w + 1.0 / w) + self.w_m
+    
+    def cal_w(self, z):
+        '''
+        Intermediate function of w(z) which only works for a single point.
+        '''
+        x = (z - self.w_m) / self.dw_h
+        w = x + np.sqrt(x ** 2.0 - 1.0 + 0j)
+        if np.absolute(w) > 1.0:
+            w = 2.0 * x - w
+        return w
+    
+    def cal_dz(self, w):
+        '''
+        Intermediate function of dz(w) which only works for single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (1.0 - 1.0 / w ** 2.0)
+    
+    def z(self, w):
+        '''
+        Calculate z from w.
+        '''
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        '''
+        Calculate w from z.
+        '''
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        '''
+        Calculate dz/dw at value w.
+        '''
+        return np.vectorize(self.cal_dz)(w)

mini_pole-0.3/mini_pole/esprit.py

@@ -0,0 +1,154 @@
+import numpy as np
+from kneed import KneeLocator
+import warnings
+
+class ESPRIT:
+    '''
+    Matrix version of the ESPRIT method for approximating functions with complex exponentials.
+    '''
+    def __init__(self, h_k, x_min = 0, x_max = 1, err = None, err_type = "abs", M = None, Lfactor = 0.4, tol = 1.e-15, ctrl_ratio = 10):
+        '''
+        Initialize with function values sampled on a uniform grid from x_min to x_max.
+        '''
+        h_k = h_k.reshape(h_k.shape[0], -1)
+        self.N = h_k.shape[0]
+        self.dim = h_k.shape[1]
+        if Lfactor < 1.0 / 3.0 or Lfactor > 0.5:
+            warnings.warn("It is suggested to set 1 / 3 <= Lfactor <= 1 / 2.")
+        self.L = int(Lfactor * (self.N - 1))
+        assert (self.N - self.L) >= (self.L + 1)
+        assert x_min < x_max
+        assert err_type in ["abs", "rel"]
+        
+        if np.max(np.abs(h_k.imag)) < tol:
+            self.type = "real"
+            self.h_k = np.array(h_k.real)
+        elif np.max(np.abs(h_k.real)) < tol:
+            self.type = "imag"
+            self.h_k = np.array(1j * h_k.imag)
+        else:
+            self.type = "cplx"
+            self.h_k = np.array(h_k)
+        self.x_min = x_min
+        self.x_max = x_max
+        self.x_k = np.linspace(self.x_min, self.x_max, self.N)
+        self.err = err
+        self.err_type = err_type
+        self.M = M
+        self.tol = tol
+        
+        #note to set data type to be complex even if the input is real! Otherwise the result might be unstable!
+        self.H = np.zeros((self.dim * (self.N - self.L), self.L + 1), dtype=np.complex128)
+        for l in range(self.N - self.L):
+            self.H[(self.dim * l):(self.dim * (l + 1)), :] = self.h_k[l:(l + self.L + 1)].T
+        
+        #for some specific versions of numpy, there is a very low chance that SVD does not converge
+        while True:
+            try:
+                _, self.S, self.W = np.linalg.svd(self.H, full_matrices=False)
+                break
+            except:
+                #reconstruct the Hankel matrix
+                self.L -= 1
+                self.H = np.zeros((self.dim * (self.N - self.L), self.L + 1), dtype=np.complex128)
+                for l in range(self.N - self.L):
+                    self.H[(self.dim * l):(self.dim * (l + 1)), :] = self.h_k[l:(l + self.L + 1)].T
+        
+        if self.M is None:
+            self.find_M_with_err() if self.err is not None else self.find_M_with_exp_decay()
+            if self.S[self.M] / self.S[0] < 1.e-14:
+                self.err = 1.e-14
+                self.err_type = "rel"
+                self.find_M_with_err()
+        else:
+            self.M = min(self.M, self.S.size - 1)
+        while True:
+            self.sigma = self.S[self.M]
+            self.W_0 = self.W[:self.M, :-1]
+            self.W_1 = self.W[:self.M, 1:]
+            self.F_M = np.linalg.pinv(self.W_0.T) @ self.W_1.T
+            
+            self.gamma = np.linalg.eigvals(self.F_M)
+            self.find_omega()
+            self.cal_err()
+            
+            if self.err_max < max(ctrl_ratio * self.sigma, 1.e-14 * self.S[0]):
+                break
+            else:
+                self.M -= 1
+            if self.M == 0:
+                raise Exception("Could not find controlled approximation!")
+    
+    def find_M_with_err(self):
+        '''
+        Find the rank M for the given error tolerance.
+        '''
+        cutoff = self.err if self.err_type == "abs" else self.S[0] * self.err
+        for idx in range(self.S.size):
+            if self.S[idx] < cutoff:
+                break
+        if self.S[idx] >= cutoff:
+            print("err is set to be too small!")
+        self.M = idx
+    
+    def find_M_with_exp_decay(self):
+        '''
+        Find the maximum index for the exponentially decaying region.
+        '''
+        kneedle = KneeLocator(np.arange(self.S.size), np.log(self.S), S=1, curve='convex', direction='decreasing')
+        self.dlogS = np.abs(np.diff(np.log(self.S[:(kneedle.knee + 1)]), n=1))
+        self.M = np.where(self.dlogS > self.dlogS.max() / 3)[0][-1] + 1
+    
+    def find_omega(self):
+        '''
+        Find weights of corresponding nodes gamma.
+        '''
+        V = np.zeros((self.h_k.shape[0], self.M), dtype=np.complex128)
+        for i in range(V.shape[0]):
+            V[i, :] = self.gamma ** i
+        #using least-squares solution is more stable than using pseudo-inverse
+        #setting rcond=None (default) sometimes leads to incorrect result for high-precision input
+        self.omega, residuals, rank, s = np.linalg.lstsq(V, self.h_k, rcond=-1)
+        self.lstsq_quality = (residuals, rank, s)
+    
+    def cal_err(self):
+        h_k_approx = self.get_value(self.x_k)
+        self.err_max = np.abs(h_k_approx - self.h_k).max(axis=0).max()
+        self.err_ave = np.abs(h_k_approx - self.h_k).mean(axis=0).max()
+    
+    def get_value_indiv(self, x, col):
+        '''
+        Get the approximated function value at point x for column col.
+        '''
+        assert col >= 0 and col < self.dim
+        x0 = (x - self.x_min) / (self.x_max - self.x_min)
+        if np.any(x0 < -1.e-12) or np.any(x0 > 1.0 + 1.e-12):
+            warnings.warn("This approximation only has error control for x in [x_min, x_max]!")
+        
+        if np.isscalar(x0):
+            V = self.gamma ** ((self.h_k.shape[0] - 1) * x0)
+            value = np.dot(V, self.omega[:, col])
+        else:
+            V = np.zeros((x0.size, self.gamma.size), dtype=np.complex128)
+            for i in range(V.shape[0]):
+                V[i, :] = self.gamma ** ((self.h_k.shape[0] - 1) * x0[i])
+            value = np.dot(V, self.omega[:, col])
+        return value if self.type == "cplx" else value.real if self.type == "real" else 1j * value.imag
+    
+    def get_value(self, x):
+        '''
+        Get the approximated function value at point x.
+        '''
+        x0 = (x - self.x_min) / (self.x_max - self.x_min)
+        if np.any(x0 < -1.e-12) or np.any(x0 > 1.0 + 1.e-12):
+            warnings.warn("This approximation only has error control for x in [x_min, x_max]!")
+        
+        if np.isscalar(x0):
+            V = self.gamma ** ((self.h_k.shape[0] - 1) * x0)
+            value = np.dot(V, self.omega)
+        else:
+            V = np.zeros((x0.size, self.gamma.size), dtype=np.complex128)
+            for i in range(V.shape[0]):
+                V[i, :] = self.gamma ** ((self.h_k.shape[0] - 1) * x0[i])
+            value = np.dot(V, self.omega)
+        return value if self.type == "cplx" else value.real if self.type == "real" else 1j * value.imag