quantalyze 0.1.0__tar.gz

quantalyze-0.1.0/.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

quantalyze-0.1.0/.python-version

@@ -0,0 +1 @@
+3.9

quantalyze-0.1.0/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

quantalyze-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: quantalyze
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: scipy>=1.13.1
+Description-Content-Type: text/markdown
+
+# Quantalyze
+
+Utilities for analyzing data.

quantalyze-0.1.0/README.md

@@ -0,0 +1,3 @@
+# Quantalyze
+
+Utilities for analyzing data.

quantalyze-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "quantalyze"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "matplotlib>=3.9.4",
+    "numpy>=2.0.2",
+    "pandas>=2.2.3",
+    "pytest>=8.3.5",
+    "scipy>=1.13.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

quantalyze-0.1.0/src/quantalyze/__init__.py

@@ -0,0 +1,4 @@
+# This file makes the directory a package.
+from .core import *
+from .transport import *
+from .thermometry import *

quantalyze-0.1.0/src/quantalyze/core/__init__.py

@@ -0,0 +1,4 @@
+from .fitting import Fit, fit
+from .symmetrize import symmetrize, antisymmetrize
+from .smoothing import bin, window, savgol_filter
+from .differentiation import backward_difference, forward_difference, central_difference, derivative

quantalyze-0.1.0/src/quantalyze/core/differentiation.py

@@ -0,0 +1,71 @@
+def forward_difference(df, x_column, y_column):
+    """
+    Calculate the forward difference of a given DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The DataFrame containing the data.
+    x_column (str): The name of the column representing the x-values.
+    y_column (str): The name of the column representing the y-values.
+
+    Returns:
+    pandas.Series: A Series containing the forward differences of the y-values with respect to the x-values.
+    """
+    forward_diff = df[y_column].diff().shift(-1) / df[x_column].diff().shift(-1)
+    return forward_diff
+
+
+def backward_difference(df, x_column, y_column):
+    """
+    Calculate the backward difference of a DataFrame column.
+
+    Parameters:
+    df (pandas.DataFrame): The DataFrame containing the data.
+    x_column (str): The name of the column to use as the x-values.
+    y_column (str): The name of the column to use as the y-values.
+
+    Returns:
+    pandas.Series: The backward difference of the y_column with respect to the x_column.
+    """
+    backward_diff = df[y_column].diff() / df[x_column].diff()
+    return backward_diff
+
+
+def central_difference(df, x_column, y_column):
+    """
+    Calculate the central difference for a given DataFrame.
+
+    The central difference is computed as the average of the forward difference
+    and the backward difference for the specified columns.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column representing the x-values.
+    y_column (str): The name of the column representing the y-values.
+
+    Returns:
+    pandas.Series: A Series containing the central difference values.
+    """
+    forward_diff = forward_difference(df, x_column, y_column)
+    backward_diff = backward_difference(df, x_column, y_column)
+    central_diff = (forward_diff + backward_diff) / 2
+    return central_diff
+
+
+
+def derivative(df, x_column, y_column):
+    """
+    Calculate the derivative of the y_column with respect to the x_column.
+
+    This method computes the numerical derivative of a given y_column with respect to an x_column
+    in a pandas DataFrame using central difference method.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column representing the x-axis.
+    y_column (str): The name of the column representing the y-axis.
+
+    Returns:
+    pandas.Series: A Series with the derivative values.
+    """
+    return central_difference(df, x_column, y_column)
+    

quantalyze-0.1.0/src/quantalyze/core/fitting.py

@@ -0,0 +1,90 @@
+from scipy.optimize import curve_fit
+from inspect import signature
+
+
+class Fit:
+    
+    def __init__(self, func, popt, pcov):
+        self.func = func
+        self.popt = popt
+        self.pcov = pcov
+
+
+    def evaluate(self, x):
+        """
+        Evaluate the fitted function at given data points.
+
+        Parameters:
+        x : array-like
+            The input data points where the function should be evaluated.
+
+        Returns:
+        array-like
+            The evaluated values of the fitted function at the given data points.
+        """
+        return self.func(x, *self.popt)
+
+
+    def plot(self, ax, x, **kwargs):
+        """
+        Plot the evaluated function on the given axes.
+
+        Parameters:
+        ax (matplotlib.axes.Axes): The axes on which to plot.
+        x (array-like): The x values to evaluate the function.
+        **kwargs: Additional keyword arguments to pass to the plot function.
+
+        Returns:
+        None
+        """
+        ax.plot(x, self.evaluate(x), **kwargs)
+
+
+def fit(func, df, x_column, y_column, x_min=None, x_max=None, y_min=None, y_max=None, p0=None):
+    """
+    Fits a given function to data in a DataFrame within an optional x and y range.
+    
+    Parameters:
+    func (callable): The function to fit to the data. It should take x data as the first argument and parameters to fit as subsequent arguments.
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    x_column (str): The name of the column in the DataFrame to use as the x data.
+    y_column (str): The name of the column in the DataFrame to use as the y data.
+    x_min (float, optional): The minimum value of x to include in the fitting. Defaults to None.
+    x_max (float, optional): The maximum value of x to include in the fitting. Defaults to None.
+    y_min (float, optional): The minimum value of y to include in the fitting. Defaults to None.
+    y_max (float, optional): The maximum value of y to include in the fitting. Defaults to None.
+    p0 (array-like, optional): Initial guess for the parameters. Defaults to None.
+    
+    Returns:
+    Fit: An instance of the Fit class containing the fitted function and parameters.
+    """
+    # Filter the dataframe based on x_min and x_max
+    if x_min is not None:
+        df = df[df[x_column] >= x_min]
+    if x_max is not None:
+        df = df[df[x_column] <= x_max]
+    
+    # Filter the dataframe based on y_min and y_max
+    if y_min is not None:
+        df = df[df[y_column] >= y_min]
+    if y_max is not None:
+        df = df[df[y_column] <= y_max]
+    
+    # Extract x and y data
+    x_data = df[x_column].values
+    y_data = df[y_column].values
+    
+    # Check if there is data to fit
+    if len(x_data) == 0 or len(y_data) == 0:
+        raise RuntimeError("No data in the specified x or y range to fit.")
+    
+    # Check if p0 is provided and has the correct length
+    if p0 is not None:
+        num_params = len(signature(func).parameters) - 1  # Subtract 1 for the x parameter
+        if len(p0) != num_params:
+            raise ValueError(f"Initial guess p0 must have length {num_params}, but got {len(p0)}.")
+    
+    # Perform curve fitting
+    popt, pcov = curve_fit(func, x_data, y_data, p0=p0)
+    
+    return Fit(func=func, popt=popt, pcov=pcov)

quantalyze-0.1.0/src/quantalyze/core/smoothing.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+from scipy.signal import savgol_filter as scipy_savgol_filter
+
+
+
+
+
+def bin(dfs, column, minimum, maximum, width):
+    """
+    Bin the data in the specified column of the DataFrame(s) into equal-width bins and compute the mean of each bin.
+
+    Parameters:
+    dfs (pandas.DataFrame or list of pandas.DataFrame): The input DataFrame(s) containing the data to be binned.
+    column (str): The name of the column in the DataFrame(s) to be binned.
+    minimum (float): The minimum value of the range to be binned.
+    maximum (float): The maximum value of the range to be binned.
+    width (float): The width of each bin.
+
+    Returns:
+    pandas.DataFrame: A DataFrame containing the mean values of each bin, with the bin midpoints as the values in the specified column.
+    """
+    def bin_single_df(df):
+        bin_edges = np.arange(minimum - width / 2, maximum + width / 2 + width, width)
+        bin_midpoints = (bin_edges[1:] + bin_edges[:-1]) / 2
+        df['bin'] = pd.cut(df[column], bins=bin_edges, include_lowest=True)
+        binned = df.groupby('bin').agg('mean').reset_index()
+        binned[column] = bin_midpoints
+        binned = binned.drop('bin', axis=1)
+        return binned
+
+    if isinstance(dfs, list):
+        combined_df = pd.concat(dfs, ignore_index=True)
+        return bin_single_df(combined_df)
+    else:
+        return bin_single_df(dfs)
+
+
+
+def window(df, column, window_size=5, window_type='triang'):
+    """
+    Apply a rolling window smoothing to a specified column in a DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    column (str): The name of the column to which the rolling window smoothing will be applied.
+    window_size (int, optional): The size of the rolling window. Default is 5.
+    window_type (str, optional): The type of window to use. Default is 'triang'.
+
+    Returns:
+    pandas.Series: A Series with the smoothed values.
+    """
+    return df[column].rolling(window=window_size, win_type=window_type, center=True).mean()
+
+
+def savgol_filter(df, column, window_size=5, order=2):
+    """
+    Apply a Savitzky-Golay filter to a specified column in a DataFrame.
+
+    Parameters:
+    df (pandas.DataFrame): The input DataFrame containing the data.
+    column (str): The name of the column to which the Savitzky-Golay filter will be applied.
+    window_size (int, optional): The size of the window. Default is 5.
+    order (int, optional): The order of the polynomial used to fit the samples. Default is 2.
+
+    Returns:
+    pandas.Series: A Series with the smoothed values.
+    """
+    return pd.Series(scipy_savgol_filter(df[column], window_size, order), index=df.index)
+	
+

quantalyze-0.1.0/src/quantalyze/core/symmetrize.py

@@ -0,0 +1,54 @@
+import pandas as pd
+from .smoothing import bin
+
+
+
+def symmetrize(dfs, x_column, y_column, minimum, maximum, step):
+    """
+    Symmetrizes the given dataframes by combining them, filtering based on the x_column values,
+    and then averaging the y_column values with their reversed counterparts.
+
+    Parameters:
+    dfs (list of pd.DataFrame): List of dataframes to be symmetrized.
+    x_column (str): The name of the column to be used for filtering and sorting.
+    y_column (str): The name of the column to be symmetrized.
+    minimum (float): The minimum value for filtering the x_column.
+    maximum (float): The maximum value for filtering the x_column.
+    step (float): The step size for binning the x_column values.
+
+    Returns:
+    pd.DataFrame: A new dataframe with symmetrized y_column values.
+    """
+    dfs = [df[(df[x_column] >= minimum) & (df[x_column] <= maximum)] for df in dfs]
+    combined = pd.concat(dfs)
+    combined = combined.sort_values(by=x_column)
+    combined = bin(combined, x_column, -maximum, maximum, step)
+    new_df = pd.DataFrame(data={x_column: combined[x_column], 'a': combined[y_column], 'b': combined[y_column].values[::-1]})
+    new_df[y_column] = (new_df["a"]+new_df["b"])/2
+    new_df = new_df.drop(columns=['a', 'b'])
+    return new_df
+
+
+def antisymmetrize(dfs, x_column, y_column, minimum, maximum, step):
+    """
+    Antisymmetrizes the given dataframes by reflecting the y-values around the x-axis.
+
+    Parameters:
+    dfs (list of pd.DataFrame): List of dataframes to be antisymmetrized.
+    x_column (str): The name of the column representing the x-axis.
+    y_column (str): The name of the column representing the y-axis.
+    minimum (float): The minimum value of the x-axis range to consider.
+    maximum (float): The maximum value of the x-axis range to consider.
+    step (float): The step size for binning the x-axis values.
+
+    Returns:
+    pd.DataFrame: A new dataframe with antisymmetrized y-values.
+    """
+    dfs = [df[(df[x_column] >= minimum) & (df[x_column] <= maximum)] for df in dfs]
+    combined = pd.concat(dfs)
+    combined = combined.sort_values(by=x_column)
+    combined = bin(combined, x_column, -maximum, maximum, step)
+    new_df = pd.DataFrame(data={x_column: combined[x_column], 'a': combined[y_column], 'b': combined[y_column].values[::-1]})
+    new_df[y_column] = (new_df["a"]-new_df["b"])/2
+    new_df = new_df.drop(columns=['a', 'b'])
+    return new_df

quantalyze-0.1.0/src/quantalyze/plotting.py

@@ -0,0 +1,52 @@
+import matplotlib.pyplot as plt
+
+
+
+def _set_ticks_inwards(fig):
+    """
+    Set the direction of ticks on the axes to inwards.
+    
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to modify.
+    
+    Returns:
+    matplotlib.figure.Figure: The modified figure.
+    """
+    for ax in fig.axes:
+        ax.tick_params(direction='in')
+    
+    return fig
+
+
+
+def nature_single_column(fig):
+    """
+    Adjusts the size and tick orientation of a matplotlib figure to match the 
+    single-column format typically used in Nature journal publications.
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to be adjusted.
+    Returns:
+    matplotlib.figure.Figure: The adjusted figure.
+    """
+
+    fig.set_size_inches(3.5, 2.5)
+
+    _set_ticks_inwards(fig)
+
+    return fig
+
+
+def nature_double_column(fig):
+    """
+    Adjusts the size of the given figure to fit a double column format for Nature journal.
+    Parameters:
+    fig (matplotlib.figure.Figure): The figure to be adjusted.
+    Returns:
+    matplotlib.figure.Figure: The adjusted figure with the new size.
+    """
+
+    fig.set_size_inches(7.2, 4.5)
+
+    _set_ticks_inwards(fig)
+
+    return fig

quantalyze-0.1.0/src/quantalyze/thermometry.py

@@ -0,0 +1,58 @@
+import numpy as np
+from numpy.polynomial.chebyshev import Chebyshev
+
+
+class ChebychevFit:
+
+    def __init__(self, cheb_fit_R_to_T, cheb_fit_T_to_R):
+        self.cheb_fit_R_to_T = cheb_fit_R_to_T
+        self.cheb_fit_T_to_R = cheb_fit_T_to_R
+
+
+    def resistance_to_temperature(self, resistance):
+        """
+        Convert resistance to temperature using the Chebyshev fit.
+        Parameters:
+            resistance (float): Resistance in ohms.
+        Returns:
+            float: Temperature in Kelvin.
+        """
+        log_R = np.log10(resistance)
+        log_T = self.cheb_fit_R_to_T(log_R)
+        return 10**log_T
+    
+
+    def temperature_to_resistance(self, temperature):
+        """
+        Convert temperature to resistance using the Chebyshev fit.
+        Parameters:
+            temperature (float): Temperature in Kelvin.
+        Returns:
+            float: Resistance in ohms.
+        """
+        log_T = np.log10(temperature)
+        log_R = self.cheb_fit_T_to_R(log_T)
+        return 10**log_R
+
+
+def fit_chebyshev_polynomial(df, resistance_column='resistance', temperature_column='temperature', order=7):
+    """
+    Fits Chebyshev polynomials to log-log data for resistance vs. temperature.
+    
+    Parameters:
+        df (pandas.DataFrame): DataFrame containing 'resistance' and 'temperature' columns.
+        resistance_column (str): Name of the column containing resistance data.
+        temperature_column (str): Name of the column containing temperature data.
+        order (int): Order of the Chebyshev polynomial.
+    
+    Returns:
+        tuple: (Chebyshev object for R->T, Chebyshev object for T->R)
+    """
+    log_R = np.log10(df[resistance_column])
+    log_T = np.log10(df[temperature_column])
+    
+    cheb_fit_R_to_T = Chebyshev.fit(log_R, log_T, order)
+    cheb_fit_T_to_R = Chebyshev.fit(log_T, log_R, order)
+    
+    return ChebychevFit(cheb_fit_R_to_T, cheb_fit_T_to_R)
+