tigramite-fast 5.2.10.1__py3-none-any.whl

tigramite/toymodels/surrogate_generator.py

@@ -0,0 +1,319 @@
+"""Tigramite toymodels."""
+
+# Author: Jakob Runge <jakob@jakob-runge.com>
+#
+# License: GNU General Public License v3.0
+from __future__ import print_function
+import sys
+import warnings
+import copy
+import math
+import numpy as np
+
+from tigramite.toymodels import structural_causal_processes as toys
+
+
+
+def generate_linear_model_from_data(dataframe, parents, tau_max, realizations=100, 
+                generate_noise_from='covariance',  
+                T_data = None,
+                model_params=None,
+                data_transform=None,
+                mask_type='y',
+                boot_blocklength=1,
+                seed=42,
+                verbosity=0):
+    """
+    Fits a (contemporaneous and lagged) linear SCM to data, computes
+    residuals, and then generates surrogate realizations with noise drawn
+    with replacement from residuals or from a multivariate normal.
+    
+    Parameters
+    ----------
+    generate_noise_from : {'covariance', 'residuals'}
+        Whether to generate the noise from a gaussian with same mean and covariance
+        as residuals, or by drawing (with replacement) from the residuals.
+    boot_blocklength : int, or in {'cube_root', 'from_autocorrelation'}
+        Block length for block-bootstrap, which only applies to
+        generate_noise_from='residuals'. If 'from_autocorrelation', the block
+        length is determined from the decay of the autocovariance and
+        if 'cube_root' it is the cube root of the time series length.
+    seed : int, optional(default = None)
+        Seed for RandomState (default_rng)
+    """
+
+    from tigramite.models import Models
+    from sklearn.linear_model import LinearRegression
+
+    assert dataframe.analysis_mode == 'single'
+
+    random_state = np.random.default_rng(seed)
+
+    def lin_f(x): return x
+
+    if model_params is None:
+        model_params = {}
+
+    N = dataframe.N
+    T = dataframe.T[0]
+    if T_data is None:
+        T_data = T
+
+    ## Estimate noise covariance matrix of residuals
+    model = Models(dataframe=dataframe,
+                     model=LinearRegression(**model_params),
+                     data_transform=data_transform,
+                     mask_type='y',
+                     verbosity=0)
+
+    model.fit_full_model(all_parents=parents, tau_max=tau_max, return_data=True)
+
+    links_coeffs = {}
+    for j in range(N):
+        links_coeffs[j] = []
+        if len(parents[j]) > 0:
+            for ipar, par in enumerate(parents[j]):
+                links_coeffs[j].append(((par[0], int(par[1])), model.fit_results[j]['model'].coef_[ipar], lin_f))
+                if verbosity > 0:
+                    print(j, ((par[0], int(par[1])), np.round(model.fit_results[j]['model'].coef_[ipar], 2),) )
+
+    pred = model.predict_full_model(
+                new_data=None,
+                pred_params=None,
+                cut_off='max_lag_or_tau_max')
+
+    # Computes cov and mean, but internally also the residuals needed here
+    cov, mean = model.get_residuals_cov_mean(new_data=None,
+                pred_params=None,)
+
+    if generate_noise_from == 'covariance':
+        # cov = np.cov(overlapping_residuals, rowvar=0)
+        # mean = np.mean(overlapping_residuals, axis=0)   # residuals should have zero mean due to prediction including constant
+        if verbosity > 0:
+            print('covariance')
+            print(np.round(cov, 2))
+            print('mean')
+            print(np.round(mean, 2))
+
+    overlapping_residuals = model.residuals
+    len_residuals = len(overlapping_residuals)
+
+    ## Construct linear Gaussian structural causal model with this noise structure and generate many realizations with same sample size as data
+    transient_fraction = 0.2
+    size = T_data + int(math.floor(transient_fraction*T_data))
+    # datasets = {}
+
+    if generate_noise_from == 'residuals':
+        if boot_blocklength == 'cube_root':
+            boot_blocklength = max(1, int(T_data**(1/3)))
+        elif boot_blocklength == 'from_autocorrelation':
+            boot_blocklength = \
+                get_block_length(overlapping_residuals.T, xyz=np.zeros(N), mode='confidence')
+        elif type(boot_blocklength) is int and boot_blocklength > 0:
+            pass
+        else:
+            raise ValueError("boot_blocklength must be integer > 0, 'cube_root', or 'from_autocorrelation'")
+
+        # Determine the number of blocks total, rounding up for non-integer
+        # amounts
+        n_blks = int(math.ceil(float(size) / boot_blocklength))
+        if n_blks < 10:
+            raise ValueError("Only %d block(s) for block-sampling,"  %n_blks +
+                             "choose smaller boot_blocklength!")
+
+    for r in range(realizations):
+        if generate_noise_from == 'covariance':
+            noises = random_state.multivariate_normal(mean=mean, cov=cov, size=size)
+        elif generate_noise_from == 'residuals':
+
+            # Get the starting indices for the blocks
+            blk_strt = random_state.choice(np.arange(len_residuals - boot_blocklength), 
+                size=n_blks, replace=True)
+
+            # Get the empty array of block resampled values
+            boot_draw = np.zeros(n_blks*boot_blocklength, dtype='int')
+            # Fill the array of block resamples
+            for i in range(boot_blocklength):
+                boot_draw[i::boot_blocklength] = np.arange(size)[blk_strt + i]
+            # Cut to proper length
+            draw = boot_draw[:size]
+            # draw = np.random.randint(0, len(overlapping_residuals), size)    
+            noises = overlapping_residuals[draw]
+
+        else: raise ValueError("generate_noise_from has to be either 'covariance' or 'residuals'")
+
+        dataset = toys.structural_causal_process(links=links_coeffs, noises=noises, T=T_data, 
+                                                     transient_fraction=transient_fraction)[0]
+        if np.any(np.isinf(dataset)):
+            raise ValueError("Infinite data")
+
+        yield dataset
+
+    # return self   #datasets
+
+
+def get_acf(series, max_lag=None):
+    """Returns autocorrelation function.
+
+    Parameters
+    ----------
+    series : 1D-array
+        data series to compute autocorrelation from
+
+    max_lag : int, optional (default: None)
+        maximum lag for autocorrelation function. If None is passed, 10% of
+        the data series length are used.
+
+    Returns
+    -------
+    autocorr : array of shape (max_lag + 1,)
+        Autocorrelation function.
+    """
+    # Set the default max lag
+    if max_lag is None:
+        max_lag = int(max(5, 0.1*len(series)))
+    # Initialize the result
+    autocorr = np.ones(max_lag + 1)
+    # Iterate over possible lags
+    for lag in range(1, max_lag + 1):
+        # Set the values
+        y1_vals = series[lag:]
+        y2_vals = series[:len(series) - lag]
+        # Calculate the autocorrelation
+        autocorr[lag] = np.corrcoef(y1_vals, y2_vals)[0, 1]
+    return autocorr
+
+def get_block_length(array, xyz, mode):
+    """Returns optimal block length for significance and confidence tests.
+
+    Determine block length using approach in Mader (2013) [Eq. (6)] which
+    improves the method of Pfeifer (2005) with non-overlapping blocks In
+    case of multidimensional X, the max is used. Further details in [1]_.
+    Two modes are available. For mode='significance', only the indices
+    corresponding to X are shuffled in array. For mode='confidence' all
+    variables are jointly shuffled. If the autocorrelation curve fit fails,
+    a block length of 5% of T is used. The block length is limited to a
+    maximum of 10% of T.
+
+    Mader et al., Journal of Neuroscience Methods,
+    Volume 219, Issue 2, 15 October 2013, Pages 285-291
+
+    Parameters
+    ----------
+    array : array-like
+        data array with X, Y, Z in rows and observations in columns
+
+    xyz : array of ints
+        XYZ identifier array of shape (dim,).
+
+    mode : str
+        Which mode to use.
+
+    Returns
+    -------
+    block_len : int
+        Optimal block length.
+    """
+    # Inject a dependency on siganal, optimize
+    from scipy import signal, optimize
+    # Get the shape of the array
+    dim, T = array.shape
+    # Initiailize the indices
+    indices = range(dim)
+    if mode == 'significance':
+        indices = np.where(xyz == 0)[0]
+
+    # Maximum lag for autocov estimation
+    max_lag = int(0.1*T)
+    # Define the function to optimize against
+    def func(x_vals, a_const, decay):
+        return a_const * decay**x_vals
+
+    # Calculate the block length
+    block_len = 1
+    for i in indices:
+        # Get decay rate of envelope of autocorrelation functions
+        # via hilbert trafo
+        autocov = get_acf(series=array[i], max_lag=max_lag)
+        autocov[0] = 1.
+        hilbert = np.abs(signal.hilbert(autocov))
+        # Try to fit the curve
+        try:
+            popt, _ = optimize.curve_fit(
+                f=func,
+                xdata=np.arange(0, max_lag+1),
+                ydata=hilbert,
+            )
+            phi = popt[1]
+            # Formula of Mader (2013) assuming non-overlapping blocks
+            l_opt = (4. * T * (phi / (1. - phi) + phi**2 / (1. - phi)**2)**2
+                     / (1. + 2. * phi / (1. - phi))**2)**(1. / 3.)
+            block_len = max(block_len, int(l_opt))
+
+            # pylab.plot(np.arange(0, max_lag+1), hilbert)
+            # pylab.plot(np.arange(0, max_lag+1), func(np.arange(0, max_lag+1), popt[0], popt[1]))
+            # print("block_len ", block_len, int(l_opt))
+            # pylab.show()
+        except RuntimeError:
+            warnings.warn("Error - curve_fit failed for estimating block_shuffle length, using"
+                  " block_len = %d" % (int(.05 * T)))
+            # block_len = max(int(.05 * T), block_len)
+
+    # print("chosen ", block_len)
+    # Limit block length to a maximum of 10% of T
+    block_len = min(block_len, int(0.1 * T))
+    # print("chosen ", block_len)
+
+    return block_len
+
+
+if __name__ == '__main__':
+
+
+    import tigramite
+    from tigramite import data_processing as pp
+
+    lin_f = lambda x: x
+    links_coeffs = {0: [((0, -1), 0.98, lin_f), ((0, -2), -0.7, lin_f)],
+                    1: [((1, -1), 0.9, lin_f), ((0, -1), 0.3, lin_f)],
+                    2: [((2, -1), 0.9, lin_f), ((0, -2), -0.5, lin_f)],
+                    3: [((3, -1), 0.9, lin_f)], #, ((4, -1), 0.4, lin_f)],
+                    4: [((4, -1), 0.9, lin_f), ((3, 0), 0.5, lin_f)], #, ((3, -1), 0.3, lin_f)],
+                    }
+    T = 50     # time series length
+    # Make some noise with different variance, alternatively just noises=None
+    noises = None  # np.array([(1. + 0.2*float(j))*np.random.randn((T + int(math.floor(0.2*T)))) 
+                       # for j in range(len(links_coeffs))]).T
+
+    data, _ = toys.structural_causal_process(links_coeffs, T=T, noises=noises)
+    T, N = data.shape
+
+    # For generality, we include some masking
+    mask = np.zeros(data.shape, dtype='int')
+    mask[:int(T/2),0] = True
+    # mask[int(T/2)+30:,1] = True
+    # Create some missing samples at different time points
+    data[11,0] = 9999.
+    data[22,2] = 9999.
+    data[33,3] = 9999.
+
+    tau_max = 4
+    # Initialize dataframe object, specify time axis and variable names
+    var_names = [r'$X^0$', r'$X^1$', r'$X^2$', r'$X^3$', r'$X^4$']
+    dataframe = pp.DataFrame(data, 
+                             mask=mask,
+                             missing_flag = 9999.,
+                             datatime = {0:np.arange(len(data))}, 
+                             var_names=var_names)
+    parents = {}
+    for j in links_coeffs:
+        parents[j] = []
+        for par in links_coeffs[j]:
+            parents[j].append(par[0])
+    print(parents)
+    datasets = list(generate_linear_model_from_data(dataframe, parents=parents, 
+                tau_max=tau_max, realizations=100, 
+                generate_noise_from='residuals',
+                boot_blocklength=3, #'from_autocorrelation',
+                verbosity=0))
+    print(datasets[0].shape)

tigramite_fast-5.2.10.1.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: tigramite-fast
+Version: 5.2.10.1
+Summary: Tigramite causal inference for time series
+Home-page: https://github.com/jakobrunge/tigramite/
+Author: Jakob Runge
+Author-email: jakob@jakob-runge.com
+License: GNU General Public License v3.0
+Keywords: causal inference,causal discovery,prediction,time series
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: numpy>=1.18
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: six
+Provides-Extra: all
+Requires-Dist: scikit-learn>=1.2; extra == "all"
+Requires-Dist: matplotlib>=3.7.0; extra == "all"
+Requires-Dist: seaborn>=0.12.2; extra == "all"
+Requires-Dist: networkx>=3.0; extra == "all"
+Requires-Dist: torch>=1.13.1; extra == "all"
+Requires-Dist: gpytorch>=1.9.1; extra == "all"
+Requires-Dist: dcor>=0.6; extra == "all"
+Requires-Dist: joblib>=1.2.0; extra == "all"
+Requires-Dist: ortools>=9.2; extra == "all"
+Requires-Dist: numba>=0.58; extra == "all"
+Provides-Extra: test
+Requires-Dist: nose; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: networkx>=3.0; extra == "test"
+Requires-Dist: scikit-learn>=1.2; extra == "test"
+Requires-Dist: pytorch>=1.13.1; extra == "test"
+Requires-Dist: gpytorch>=1.9.1; extra == "test"
+Requires-Dist: dcor>=0.6; extra == "test"
+Provides-Extra: dev
+Requires-Dist: scikit-learn>=1.2; extra == "dev"
+Requires-Dist: matplotlib>=3.7.0; extra == "dev"
+Requires-Dist: seaborn>=0.12.2; extra == "dev"
+Requires-Dist: networkx>=3.0; extra == "dev"
+Requires-Dist: torch>=1.13.1; extra == "dev"
+Requires-Dist: gpytorch>=1.9.1; extra == "dev"
+Requires-Dist: dcor>=0.6; extra == "dev"
+Requires-Dist: joblib>=1.2.0; extra == "dev"
+Requires-Dist: ortools>=9.2; extra == "dev"
+Requires-Dist: numba>=0.58; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# Tigramite – Causal inference for time series datasets
+![logo](docs/_images/tigramite_logo_header.png)
+Version 5.2
+(Python Package)
+
+[Github](https://github.com/jakobrunge/tigramite.git)
+
+[Documentation](https://jakobrunge.github.io/tigramite/)
+
+[Tutorials](https://github.com/jakobrunge/tigramite/tree/master/tutorials/)
+
+## Overview
+
+It's best to start with our [Overview/review paper: Causal inference for time series](https://github.com/jakobrunge/tigramite/blob/master/tutorials/Runge_Causal_Inference_for_Time_Series_NREE.pdf)
+
+__Update:__ Tigramite now has a new CausalEffects class that allows to estimate (conditional) causal effects and mediation based on assuming a causal graph. Have a look at the tutorial.
+
+Further, Tigramite provides several causal discovery methods that can be used under different sets of assumptions. An application always consists of a method and a chosen conditional independence test, e.g. PCMCIplus together with ParCorr. The following two tables give an overview of the assumptions involved:
+
+| Method | Assumptions         | Output |
+| :-- | :-- | :-- |
+|         |   (in addition to Causal Markov Condition and Faithfulness)   |    |
+| PCMCI  | Causal stationarity, no contemporaneous causal links, no hidden variables |  Directed lagged links, undirected contemporaneous links (for tau_min=0)  |
+| PCMCIplus | Causal stationarity, no hidden variables    | Directed lagged links, directed and undirected contemp. links (Time series CPDAG) |
+| LPCMCI | Causal stationarity    | Time series PAG |
+| RPCMCI  | No contemporaneous causal links, no hidden variables |  Regime-variable and causal graphs for each regime with directed lagged links, undirected contemporaneous links (for tau_min=0)  |
+| J-PCMCI+ | Multiple datasets, causal stationarity, no hidden system confounding, except if context-related   | Directed lagged links, directed and undirected contemp. links (Joint time series CPDAG) |
+
+
+| Conditional independence test | Assumptions                                                                                            |
+| :-- | :-- | 
+| ParCorr                       | univariate, continuous variables with linear dependencies and Gaussian noise                           |
+| RobustParCorr                 | univariate, continuous variables with linear dependencies, robust for different marginal distributions |
+| ParCorrWLS                    | univariate, continuous variables with linear dependencies, can account for heteroskedastic data        |
+| GPDC / GPDCtorch              | univariate, continuous variables with additive dependencies                                            |
+| CMIknn                        | multivariate, continuous variables with more general dependencies (permutation-based test)             |
+| Gsquared                      | univariate discrete/categorical variables                                                              |
+| CMIsymb                       | multivariate discrete/categorical variables (permutation-based test)                                   |
+| RegressionCI                  | mixed datasets with univariate discrete/categorical and (linear) continuous variables                  |
+| CMIknnMixed                  | mixed datasets with multivariate discr./cat./cont. variables with more general dependencies (permutation-based test)                  |
+
+Remark: With the conditional independence test wrapper class PairwiseMultCI you can turn every univariate test into a multivariate test.
+
+## General Notes
+
+Tigramite is a causal inference for time series python package. It allows to efficiently estimate causal graphs from high-dimensional time series datasets (causal discovery) and to use graphs for robust forecasting and the estimation and prediction of direct, total, and mediated effects. Causal discovery is based on linear as well as non-parametric conditional independence tests applicable to discrete or continuously-valued time series. Also includes functions for high-quality plots of the results. Please cite the following papers depending on which method you use:
+
+- Overview: Runge, J., Gerhardus, A., Varando, G. et al. Causal inference for time series. Nat Rev Earth Environ (2023). https://doi.org/10.1038/s43017-023-00431-y
+
+- PCMCI: J. Runge, P. Nowack, M. Kretschmer, S. Flaxman, D. Sejdinovic, Detecting and quantifying causal associations in large nonlinear time series datasets. Sci. Adv. 5, eaau4996 (2019). https://advances.sciencemag.org/content/5/11/eaau4996
+- PCMCI+: J. Runge (2020): Discovering contemporaneous and lagged causal relations in autocorrelated nonlinear time series datasets. Proceedings of the 36th Conference on Uncertainty in Artificial Intelligence, UAI 2020,Toronto, Canada, 2019, AUAI Press, 2020. http://auai.org/uai2020/proceedings/579_main_paper.pdf
+- LPCMCI: Gerhardus, A. & Runge, J. High-recall causal discovery for autocorrelated time series with latent confounders Advances in Neural Information Processing Systems, 2020, 33. https://proceedings.neurips.cc/paper/2020/hash/94e70705efae423efda1088614128d0b-Abstract.html
+- RPCMCI: Elena Saggioro, Jana de Wiljes, Marlene Kretschmer, Jakob Runge; Reconstructing regime-dependent causal relationships from observational time series. Chaos 1 November 2020; 30 (11): 113115. https://doi.org/10.1063/5.0020538
+- Generally: J. Runge (2018): Causal Network Reconstruction from Time Series: From Theoretical Assumptions to Practical Estimation. Chaos: An Interdisciplinary Journal of Nonlinear Science 28 (7): 075310. https://aip.scitation.org/doi/10.1063/1.5025050
+- Nature Communications Perspective paper: https://www.nature.com/articles/s41467-019-10105-3
+- Mediation class: J. Runge et al. (2015): Identifying causal gateways and mediators in complex spatio-temporal systems. Nature Communications, 6, 8502. http://doi.org/10.1038/ncomms9502
+- Mediation class: J. Runge (2015): Quantifying information transfer and mediation along causal pathways in complex systems. Phys. Rev. E, 92(6), 62829. http://doi.org/10.1103/PhysRevE.92.062829
+- CMIknn: J. Runge (2018): Conditional Independence Testing Based on a Nearest-Neighbor Estimator of Conditional Mutual Information. In Proceedings of the 21st International Conference on Artificial Intelligence and Statistics. http://proceedings.mlr.press/v84/runge18a.html
+- CausalEffects: J. Runge, Necessary and sufficient graphical conditions for optimal adjustment sets in causal graphical models with hidden variables, Advances in Neural Information Processing Systems, 2021, 34. https://proceedings.neurips.cc/paper/2021/hash/8485ae387a981d783f8764e508151cd9-Abstract.html
+- CMIknnMixed: Oana-Iuliana Popescu, Andreas Gerhardus, Martin Rabel, Jakob Runge (2024), submitted to CLEAR 2025, https://arxiv.org/abs/2310.11132
+
+## Features
+
+- flexible conditional independence test statistics adapted to
+  continuously-valued, discrete and mixed data, and different assumptions about
+  linear or nonlinear dependencies
+- handling of missing values and masks
+- p-value correction and (bootstrap) confidence interval estimation
+- causal effect class to  non-parametrically estimate (conditional) causal effects and also linear mediated causal effects
+- prediction class based on sklearn models including causal feature selection
+
+## Required python packages
+
+- python>=3.10
+- numpy>=1.18
+- scipy>=1.10.0
+- numba>=0.56.4
+
+## Optional packages depending on used functions
+- scikit-learn>=1.2   # Gaussian Process (GP) Regression
+- matplotlib>=3.7.0   # Plotting
+- seaborn>=0.12.2     # Plotting
+- networkx>=3.0       # Plotting
+- torch>=1.13.1       # GPDC pytorch version (in conda install pytorch)
+- gpytorch>=1.9.1     # GPDC gpytorch version
+- dcor>=0.6           # GPDC distance correlation version
+- joblib>=1.2.0       # CMIsymb shuffle parallelization
+- ortools>=9.2        # RPCMCI
+
+## Installation
+
+python setup.py install
+
+This will install tigramite in your path.
+
+To use just the ParCorr, CMIknn, and CMIsymb independence tests, only numpy/numba and scipy are required. For other independence tests more packages are required:
+
+- GPDC: scikit-learn is required for Gaussian Process regression and dcor for distance correlation
+
+- GPDCtorch: gpytorch is required for Gaussian Process regression
+
+Note: Due to incompatibility issues between numba and numpy, we currently enforce soft dependencies on the versions.
+
+## User Agreement
+
+By downloading TIGRAMITE you agree with the following points: TIGRAMITE is provided without any warranty or conditions of any kind. We assume no responsibility for errors or omissions in the results and interpretations following from application of TIGRAMITE.
+
+You commit to cite above papers in your reports or publications.
+
+
+## License
+
+Copyright (C) 2014-2025 Jakob Runge
+
+See license.txt for full text.
+
+GNU General Public License v3.0
+
+TIGRAMITE is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. TIGRAMITE is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

tigramite_fast-5.2.10.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+tigramite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tigramite/causal_effects.py,sha256=yCEezbLmo5sMA0HOv2aCGHvpFjvQ_ocN8SGxZbbq1no,58582
+tigramite/causal_mediation.py,sha256=u2749xbiq2KIwnVqheBP3Prd6TDmXNpk8ZHceX9E-Wg,71024
+tigramite/data_processing.py,sha256=Wb15aVRaqx93TpDrkOYbetg_k3z_2EMUtoQLveKnGPM,66977
+tigramite/graphs.py,sha256=-b3ePCEFgDVopU15iomSoF7PkpW1qPIb0fOCxNYpKtc,60541
+tigramite/jpcmciplus.py,sha256=BfKlkUDT9MFq9c5O3c-yHINVKVd9PPGOnaB7lw24AeE,49043
+tigramite/lpcmci.py,sha256=uet3oN3NyIg5frqhF2yoiggp9AShv7FVT_ke0h_30TE,173012
+tigramite/models.py,sha256=M_oEDyu33RYw7hDAZK2jjoKAOuS66Ja9OQ1iC3yIM2E,87465
+tigramite/pcmci.py,sha256=qJe-HxB0bvsyFQ8oqCn4dfPy9z6Y2WOVJHlY_Vz7Alw,175905
+tigramite/pcmci_base.py,sha256=gscRFLi55yNw1CSCGGJawYE82eWnDhwDe0E7B-3mdM0,52292
+tigramite/plotting.py,sha256=-tga5nOnMawHpCsg40dsbq9321i0kNjSPx4UYYt5THQ,170061
+tigramite/rpcmci.py,sha256=vEEdKy4u6Xx55DkFdY_pmYxu8xi8HfLI0yKCD6WeVI0,19620
+tigramite/independence_tests/LBFGS.py,sha256=B1SDZp23qHBIz2pvUJaHGqlNk5MS0rxjnKFx7MyqlqA,43660
+tigramite/independence_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tigramite/independence_tests/cmiknn.py,sha256=9JRtRszMSuIxtutdJcTBQBqyL36UBsk1Zaflb1sk3G4,25263
+tigramite/independence_tests/cmiknn_mixed.py,sha256=NxmRN0IxW5tInwDF5qfSpI2_0TaPbC3aeUkQYHxapXo,56741
+tigramite/independence_tests/cmisymb.py,sha256=dmgFTAdikadnInDAQtnnTywXo8Wm0rivwZi2ybJCMjg,11050
+tigramite/independence_tests/gpdc.py,sha256=rpWZCTbvrHaj9m7eEVH3vZj6YcgaYfPQCSNO0rwU3yc,24265
+tigramite/independence_tests/gpdc_torch.py,sha256=DESgxrq7gY_DFTTQylC9X3FfEST47zaFGY1TKb2EQ8E,31460
+tigramite/independence_tests/gsquared.py,sha256=YqMWhB07L-sLoxzrbaRbRHPRF1JjMkukdbAd1Wh1VGs,6559
+tigramite/independence_tests/independence_tests_base.py,sha256=3fnTn9_bvFBOpUfBnn4mKERpOVCD0ArJj-qi4ePo4Tw,51770
+tigramite/independence_tests/oracle_conditional_independence.py,sha256=SrrVaXdpTTYTDhTiL15WMdYl5tEvwxl30VrhjTgLR94,63379
+tigramite/independence_tests/pairwise_CI.py,sha256=QOERKQBE7FYRVXymCz8pgK2ONZyTvHPhP4OiT_sHqR4,18271
+tigramite/independence_tests/parcorr.py,sha256=2PrHHhVGSotyMQX4EAEEbJCySKmv9bv5C3vsG_LH_pw,12024
+tigramite/independence_tests/parcorr_mult.py,sha256=H-1wJriPYmkRgezNxkgUmhBnw-IRTSm9cTL5rPACrJQ,16318
+tigramite/independence_tests/parcorr_wls.py,sha256=Cv2zWsdXX7UZ_PeHVmT87lOhbpQtfi--3qnWszSs7G0,18794
+tigramite/independence_tests/regressionCI.py,sha256=290KzuQhBkRZ_z_PM4om3yWP84B_P9ewJ9IunjjgCik,15008
+tigramite/independence_tests/robust_parcorr.py,sha256=_u35qBXaGsF6SDx_EDEn1OV0iUN9NzpTFsfdwdDA-jI,13805
+tigramite/toymodels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tigramite/toymodels/context_model.py,sha256=ixV7GcIxjfw8H-h2shhwVOFpQImPjtxFHNMGaGu0OFo,13239
+tigramite/toymodels/non_additive.py,sha256=4PCyWfY6n_jkKVa49VRjzZWI235mk6EHUJyFcyQuOH4,45161
+tigramite/toymodels/structural_causal_processes.py,sha256=y5HIlbFNdWn_cUVeFkdTxxEF-MWRWZ4GRxvY0sGEmc4,43363
+tigramite/toymodels/surrogate_generator.py,sha256=GNRB2s9zHOktJE0uCLnc4t8DPKANyrM2VkXnjIffMGw,11942
+tigramite_fast-5.2.10.1.dist-info/licenses/license.txt,sha256=scVEb0_a6u-SwMjZ00QjylmopLfNbR6V0AMYjbLsbPM,32453
+tigramite_fast-5.2.10.1.dist-info/METADATA,sha256=U05ETTtXHfqcAgroJ46kDbbrwiHlI8bbjhqf6BVOTn0,11862
+tigramite_fast-5.2.10.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tigramite_fast-5.2.10.1.dist-info/top_level.txt,sha256=i9LendHtmnjM0otoYjPjyiaLR0qTHLUxr7Fam_PHamY,10
+tigramite_fast-5.2.10.1.dist-info/RECORD,,

tigramite_fast-5.2.10.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+